lib

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

source_ingress.rs (31498B)


      1 //! Bounded fetch admission at the shared socket's pre-Nostr decoding boundary.
      2 
      3 use crate::source::budget::FetchBudget;
      4 use futures::task::AtomicWaker;
      5 use std::{
      6     collections::{BTreeMap, BTreeSet},
      7     sync::{Arc, Mutex},
      8     task::Context,
      9 };
     10 
     11 const MAX_ACTIVE_SCOPES: usize = 64;
     12 
     13 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
     14 enum ScopeMode {
     15     Fetch,
     16     Live,
     17 }
     18 
     19 #[derive(Debug, Default)]
     20 struct RelayState {
     21     generation: u64,
     22     invalidated: u64,
     23     waker: AtomicWaker,
     24     write_waker: AtomicWaker,
     25 }
     26 
     27 #[derive(Debug)]
     28 struct Registration {
     29     targets: BTreeSet<String>,
     30     budget: Arc<FetchBudget>,
     31     originals: Vec<OriginalScope>,
     32     mode: ScopeMode,
     33 }
     34 
     35 #[derive(Debug)]
     36 struct OriginalScope {
     37     relay: String,
     38     subscription: String,
     39     scope: u64,
     40 }
     41 
     42 #[derive(Debug, Default)]
     43 struct State {
     44     sequence: u64,
     45     original_sequence: u64,
     46     relays: BTreeMap<String, RelayState>,
     47     active: BTreeMap<u64, Registration>,
     48     originals: crate::source_original::OriginalQueue,
     49 }
     50 
     51 #[derive(Clone, Debug, Default)]
     52 pub(crate) struct IngressRegistry(Arc<Mutex<State>>);
     53 
     54 impl IngressRegistry {
     55     pub(crate) fn new(targets: impl Iterator<Item = String>) -> Self {
     56         Self(Arc::new(Mutex::new(State {
     57             relays: targets
     58                 .map(|target| (target, RelayState::default()))
     59                 .collect(),
     60             ..State::default()
     61         })))
     62     }
     63 
     64     pub(crate) fn register(
     65         &self,
     66         targets: impl Iterator<Item = String>,
     67         budget: Arc<FetchBudget>,
     68     ) -> Option<IngressRegistration> {
     69         self.register_scope(targets, budget, ScopeMode::Fetch)
     70     }
     71 
     72     pub(crate) fn register_live(
     73         &self,
     74         targets: impl Iterator<Item = String>,
     75     ) -> Option<IngressRegistration> {
     76         self.register_scope(targets, Arc::new(FetchBudget::default()), ScopeMode::Live)
     77     }
     78 
     79     fn register_scope(
     80         &self,
     81         targets: impl Iterator<Item = String>,
     82         budget: Arc<FetchBudget>,
     83         mode: ScopeMode,
     84     ) -> Option<IngressRegistration> {
     85         let mut state = self.0.lock().ok()?;
     86         if state.active.len() == MAX_ACTIVE_SCOPES {
     87             return None;
     88         }
     89         let targets: BTreeSet<_> = targets.collect();
     90         if targets
     91             .iter()
     92             .any(|target| !state.relays.contains_key(target))
     93         {
     94             return None;
     95         }
     96         let id = state.sequence.checked_add(1)?;
     97         state.sequence = id;
     98         state.active.insert(
     99             id,
    100             Registration {
    101                 targets,
    102                 budget,
    103                 originals: Vec::new(),
    104                 mode,
    105             },
    106         );
    107         Some(IngressRegistration {
    108             registry: self.clone(),
    109             id,
    110             finished: false,
    111         })
    112     }
    113 
    114     pub(crate) fn connection(&self, relay: &str) -> Option<IngressConnection> {
    115         let mut state = self.0.lock().ok()?;
    116         let row = state.relays.get_mut(relay)?;
    117         row.generation = row.generation.checked_add(1)?;
    118         row.waker.wake();
    119         row.write_waker.wake();
    120         Some(IngressConnection {
    121             registry: self.clone(),
    122             relay: relay.to_owned(),
    123             generation: row.generation,
    124         })
    125     }
    126 
    127     fn admitted(&self, relay: &str, generation: u64, context: &Context<'_>, write: bool) -> bool {
    128         let Ok(state) = self.0.lock() else {
    129             return false;
    130         };
    131         let Some(row) = state.relays.get(relay) else {
    132             return false;
    133         };
    134         if generation <= row.invalidated || generation != row.generation {
    135             return false;
    136         }
    137         if write {
    138             row.write_waker.register(context.waker());
    139         } else {
    140             row.waker.register(context.waker());
    141         }
    142         true
    143     }
    144 
    145     fn charge(
    146         &self,
    147         relay: &str,
    148         generation: u64,
    149         bytes: usize,
    150         frames: usize,
    151         data: usize,
    152     ) -> bool {
    153         let Ok(mut state) = self.0.lock() else {
    154             return false;
    155         };
    156         let Some(row) = state.relays.get(relay) else {
    157             return false;
    158         };
    159         if generation <= row.invalidated || generation != row.generation {
    160             return false;
    161         }
    162         let mut denied = BTreeSet::new();
    163         for entry in state.active.values() {
    164             if entry.mode == ScopeMode::Fetch
    165                 && entry.targets.contains(relay)
    166                 && !entry.budget.wire(bytes, frames, data)
    167             {
    168                 denied.extend(entry.targets.iter().cloned());
    169             }
    170         }
    171         for target in &denied {
    172             if let Some(row) = state.relays.get_mut(target) {
    173                 row.invalidated = row.generation;
    174                 row.waker.wake();
    175                 row.write_waker.wake();
    176             }
    177         }
    178         denied.is_empty()
    179     }
    180 
    181     fn remove(&self, id: u64, cancel: bool) -> bool {
    182         let Ok(mut state) = self.0.lock() else {
    183             return false;
    184         };
    185         let Some(entry) = state.active.remove(&id) else {
    186             return false;
    187         };
    188         state.originals.remove_owner(id);
    189         // Charge and completion use this same mutex. No ingress can exhaust
    190         // this registration between the budget check and its removal.
    191         let complete = !cancel && !entry.budget.exhausted();
    192         if !complete && entry.mode == ScopeMode::Fetch {
    193             for target in entry.targets {
    194                 if let Some(row) = state.relays.get_mut(&target) {
    195                     row.invalidated = row.generation;
    196                     row.waker.wake();
    197                     row.write_waker.wake();
    198                 }
    199             }
    200         }
    201         complete
    202     }
    203 
    204     fn bind_originals(
    205         &self,
    206         owner: u64,
    207         relay: &str,
    208         subscription: &str,
    209     ) -> Option<OriginalSubscription> {
    210         if subscription.is_empty() || subscription.len() > 256 {
    211             return None;
    212         }
    213         let mut state = self.0.lock().ok()?;
    214         if state.active.values().any(|entry| {
    215             entry
    216                 .originals
    217                 .iter()
    218                 .any(|scope| scope.relay == relay && scope.subscription == subscription)
    219         }) {
    220             return None;
    221         }
    222         let entry = state.active.get(&owner)?;
    223         if !entry.targets.contains(relay) || entry.originals.len() >= crate::client::MAX_RELAYS {
    224             return None;
    225         }
    226         let scope = state.original_sequence.checked_add(1)?;
    227         state.original_sequence = scope;
    228         state.active.get_mut(&owner)?.originals.push(OriginalScope {
    229             relay: relay.into(),
    230             subscription: subscription.into(),
    231             scope,
    232         });
    233         Some(OriginalSubscription {
    234             registry: self.clone(),
    235             owner,
    236             scope,
    237         })
    238     }
    239 
    240     fn capture(&self, relay: &str, generation: u64, text: &str) -> bool {
    241         let Some((subscription, raw)) = crate::source_original::frame(text) else {
    242             return true;
    243         };
    244         let selected = {
    245             let Ok(state) = self.0.lock() else {
    246                 return false;
    247             };
    248             if !state
    249                 .relays
    250                 .get(relay)
    251                 .is_some_and(|row| generation == row.generation && generation > row.invalidated)
    252             {
    253                 return false;
    254             }
    255             state.active.iter().find_map(|(owner, entry)| {
    256                 entry
    257                     .originals
    258                     .iter()
    259                     .find(|scope| scope.relay == relay && scope.subscription == subscription)
    260                     .map(|scope| (*owner, scope.scope))
    261             })
    262         };
    263         let Some((owner, scope)) = selected else {
    264             return true;
    265         };
    266         // Reuse the exact pinned upstream decoder only to correlate its later
    267         // notification. It supplies no authentication or original-wire admission.
    268         let Ok(event) = nostr_sdk::prelude::Event::from_json(raw.get()) else {
    269             return true;
    270         };
    271         let correlation = crate::source_original::correlation(&event);
    272         let Ok(mut state) = self.0.lock() else {
    273             return false;
    274         };
    275         if !state
    276             .relays
    277             .get(relay)
    278             .is_some_and(|row| generation == row.generation && generation > row.invalidated)
    279         {
    280             return false;
    281         }
    282         let Some(entry) = state.active.get(&owner) else {
    283             return true;
    284         };
    285         if !entry.originals.iter().any(|entry| entry.scope == scope) {
    286             return true;
    287         }
    288         if entry.budget.exhausted() {
    289             return entry.mode == ScopeMode::Live;
    290         }
    291         if state.originals.insert(owner, scope, correlation, raw.get()) {
    292             return true;
    293         }
    294         let entry = &state.active[&owner];
    295         entry.budget.exhaust();
    296         if entry.mode == ScopeMode::Live {
    297             return true;
    298         }
    299         let targets = entry.targets.clone();
    300         for target in targets {
    301             if let Some(row) = state.relays.get_mut(&target) {
    302                 row.invalidated = row.generation;
    303                 row.waker.wake();
    304                 row.write_waker.wake();
    305             }
    306         }
    307         false
    308     }
    309 }
    310 
    311 pub(crate) struct IngressRegistration {
    312     registry: IngressRegistry,
    313     id: u64,
    314     finished: bool,
    315 }
    316 
    317 impl IngressRegistration {
    318     pub(crate) async fn wait_exhausted(&self) {
    319         let budget = self.registry.0.lock().ok().and_then(|state| {
    320             state
    321                 .active
    322                 .get(&self.id)
    323                 .map(|entry| Arc::clone(&entry.budget))
    324         });
    325         if let Some(budget) = budget {
    326             budget.wait_exhausted().await;
    327         }
    328     }
    329     pub(crate) fn exhausted(&self) -> bool {
    330         self.registry
    331             .0
    332             .lock()
    333             .ok()
    334             .and_then(|state| {
    335                 state
    336                     .active
    337                     .get(&self.id)
    338                     .map(|entry| entry.budget.exhausted())
    339             })
    340             .unwrap_or(true)
    341     }
    342     pub(crate) fn bind_originals(
    343         &self,
    344         relay: &str,
    345         subscription: &str,
    346     ) -> Option<OriginalSubscription> {
    347         self.registry.bind_originals(self.id, relay, subscription)
    348     }
    349     pub(crate) fn finish(mut self) -> bool {
    350         let complete = self.registry.remove(self.id, false);
    351         self.finished = true;
    352         complete
    353     }
    354 }
    355 
    356 pub(crate) struct OriginalSubscription {
    357     registry: IngressRegistry,
    358     owner: u64,
    359     scope: u64,
    360 }
    361 impl OriginalSubscription {
    362     pub(crate) fn take(&self, event: &nostr_sdk::prelude::Event) -> Option<String> {
    363         let key = crate::source_original::correlation(event);
    364         self.registry.0.lock().ok()?.originals.take(self.scope, key)
    365     }
    366 }
    367 impl Drop for OriginalSubscription {
    368     fn drop(&mut self) {
    369         if let Ok(mut state) = self.registry.0.lock() {
    370             state.originals.remove_scope(self.scope);
    371             if let Some(entry) = state.active.get_mut(&self.owner) {
    372                 entry.originals.retain(|entry| entry.scope != self.scope);
    373             }
    374         }
    375     }
    376 }
    377 
    378 impl Drop for IngressRegistration {
    379     fn drop(&mut self) {
    380         if !self.finished {
    381             self.registry.remove(self.id, true);
    382         }
    383     }
    384 }
    385 
    386 #[derive(Clone, Debug)]
    387 pub(crate) struct IngressConnection {
    388     registry: IngressRegistry,
    389     relay: String,
    390     generation: u64,
    391 }
    392 
    393 impl IngressConnection {
    394     pub(crate) fn capture(&self, text: &str) -> bool {
    395         self.registry.capture(&self.relay, self.generation, text)
    396     }
    397     pub(crate) fn admitted(&self, context: &Context<'_>) -> bool {
    398         self.registry
    399             .admitted(&self.relay, self.generation, context, false)
    400     }
    401 
    402     pub(crate) fn admitted_write(&self, context: &Context<'_>) -> bool {
    403         self.registry
    404             .admitted(&self.relay, self.generation, context, true)
    405     }
    406 
    407     pub(crate) fn charge(&self, bytes: usize, frames: usize, data: usize) -> bool {
    408         self.registry
    409             .charge(&self.relay, self.generation, bytes, frames, data)
    410     }
    411 }
    412 
    413 #[cfg(test)]
    414 mod tests {
    415     use super::*;
    416     use crate::source::budget::{MAX_FETCH_BYTES, MAX_FETCH_EVENTS, MAX_FETCH_NOTIFICATIONS};
    417 
    418     fn original() -> (String, nostr_sdk::prelude::Event) {
    419         let fixture: serde_json::Value =
    420             serde_json::from_str(include_str!("../tests/fixtures/source_original.v1.json"))
    421                 .unwrap();
    422         let raw = fixture["raw_wrap"].as_str().unwrap().to_owned();
    423         let event = nostr_sdk::prelude::Event::from_json(&raw).unwrap();
    424         (raw, event)
    425     }
    426     fn event_frame(subscription: &str, raw: &str) -> String {
    427         format!(
    428             "[\"EVENT\",{},{}]",
    429             serde_json::to_string(subscription).unwrap(),
    430             raw
    431         )
    432     }
    433 
    434     #[test]
    435     fn original_scope_refusals_and_unowned_frames_retain_no_evidence() {
    436         let registry = registry();
    437         let registration = register(&registry, &["one"], &Arc::new(FetchBudget::default()));
    438         assert!(
    439             registration
    440                 .bind_originals("one", &"a".repeat(257))
    441                 .is_none()
    442         );
    443         let mut scopes = Vec::new();
    444         for index in 0..crate::client::MAX_RELAYS {
    445             scopes.push(
    446                 registration
    447                     .bind_originals("one", &format!("scope-{index}"))
    448                     .unwrap(),
    449             );
    450         }
    451         assert!(registration.bind_originals("one", "over-limit").is_none());
    452         let connection = registry.connection("one").unwrap();
    453         let (raw, event) = original();
    454         assert!(connection.capture(&event_frame("unowned", &raw)));
    455         assert!(connection.capture(&event_frame("scope-0", "{}")));
    456         assert!(scopes[0].take(&event).is_none());
    457         assert!(connection.capture(&event_frame("scope-0", &raw)));
    458         assert_eq!(scopes[0].take(&event).as_deref(), Some(raw.as_str()));
    459         assert!(registration.finish());
    460         assert!(scopes[0].take(&event).is_none());
    461     }
    462 
    463     #[test]
    464     fn originals_are_owned_by_exact_fetch_relay_and_subscription() {
    465         let registry = registry();
    466         let first = register(&registry, &["one"], &Arc::new(FetchBudget::default()));
    467         let second = register(&registry, &["two"], &Arc::new(FetchBudget::default()));
    468         let a = first.bind_originals("one", "a").unwrap();
    469         let b = second.bind_originals("two", "a").unwrap();
    470         assert!(first.bind_originals("one", "a").is_none());
    471         assert!(first.bind_originals("missing", "b").is_none());
    472         assert!(first.bind_originals("one", "").is_none());
    473         let one = registry.connection("one").unwrap();
    474         let two = registry.connection("two").unwrap();
    475         let (raw, event) = original();
    476         assert!(one.capture(&event_frame("a", &raw)));
    477         assert!(b.take(&event).is_none());
    478         assert!(two.capture(&event_frame("a", &raw)));
    479         assert_eq!(a.take(&event).as_deref(), Some(raw.as_str()));
    480         assert_eq!(b.take(&event).as_deref(), Some(raw.as_str()));
    481         assert!(a.take(&event).is_none());
    482         assert!(first.finish());
    483         assert!(second.finish());
    484     }
    485 
    486     #[test]
    487     fn original_scope_cleanup_and_reconnection_preserve_obtained_data_and_reject_stale_ingress() {
    488         let registry = registry();
    489         let first = register(&registry, &["one"], &Arc::new(FetchBudget::default()));
    490         let scope = first.bind_originals("one", "a").unwrap();
    491         let stale = registry.connection("one").unwrap();
    492         let (raw, event) = original();
    493         assert!(stale.capture(&event_frame("a", &raw)));
    494         let fresh = registry.connection("one").unwrap();
    495         assert!(!stale.capture(&event_frame("a", &raw)));
    496         assert_eq!(scope.take(&event).as_deref(), Some(raw.as_str()));
    497         assert!(fresh.capture(&event_frame("a", &raw)));
    498         drop(scope);
    499         assert_eq!(
    500             registry.0.lock().unwrap().originals.retained_bytes(),
    501             crate::source_original::OriginalQueue::default().retained_bytes()
    502         );
    503         assert!(fresh.capture(&event_frame("a", &raw)));
    504         assert!(first.finish());
    505         registry.0.lock().unwrap().original_sequence = u64::MAX;
    506         let second = register(&registry, &["one"], &Arc::new(FetchBudget::default()));
    507         assert!(second.bind_originals("one", "b").is_none());
    508     }
    509 
    510     #[test]
    511     fn original_queue_is_globally_bounded_and_exhaustion_does_not_evict_other_fetch_data() {
    512         let registry = registry();
    513         let a_budget = Arc::new(FetchBudget::default());
    514         let b_budget = Arc::new(FetchBudget::default());
    515         let a = register(&registry, &["one"], &a_budget);
    516         let b = register(&registry, &["two"], &b_budget);
    517         let a_scope = a.bind_originals("one", "a").unwrap();
    518         let b_scope = b.bind_originals("two", "b").unwrap();
    519         let one = registry.connection("one").unwrap();
    520         let two = registry.connection("two").unwrap();
    521         let (raw, event) = original();
    522         assert!(
    523             raw.len() * crate::source_original::MAX_PENDING_EVENTS
    524                 + registry.0.lock().unwrap().originals.retained_bytes()
    525                 <= crate::source_original::MAX_PENDING_BYTES
    526         );
    527         for _ in 0..crate::source_original::MAX_PENDING_EVENTS / 2 {
    528             assert!(one.capture(&event_frame("a", &raw)));
    529             assert!(two.capture(&event_frame("b", &raw)));
    530         }
    531         assert!(!one.capture(&event_frame("a", &raw)));
    532         assert!(a_budget.exhausted());
    533         assert!(!b_budget.exhausted());
    534         assert!(!admitted(&one));
    535         assert!(admitted(&two));
    536         assert_eq!(b_scope.take(&event).as_deref(), Some(raw.as_str()));
    537         assert!(two.capture(&event_frame("b", &raw)));
    538         assert_eq!(a_scope.take(&event).as_deref(), Some(raw.as_str()));
    539         drop(a);
    540         assert!(b_scope.take(&event).is_some());
    541         assert!(b.finish());
    542         assert_eq!(
    543             registry.0.lock().unwrap().originals.retained_bytes(),
    544             crate::source_original::OriginalQueue::default().retained_bytes()
    545         );
    546     }
    547 
    548     #[test]
    549     fn live_scope_cleanup_preserves_other_subscriptions_and_has_no_cumulative_fetch_budget() {
    550         let registry = registry();
    551         let first = registry
    552             .register_live(["one".to_owned()].into_iter())
    553             .unwrap();
    554         let second = registry
    555             .register_live(["one".to_owned()].into_iter())
    556             .unwrap();
    557         let a = first.bind_originals("one", "a").unwrap();
    558         let b = second.bind_originals("one", "b").unwrap();
    559         let connection = registry.connection("one").unwrap();
    560         assert!(connection.charge(
    561             MAX_FETCH_BYTES + 1,
    562             MAX_FETCH_NOTIFICATIONS + 1,
    563             MAX_FETCH_EVENTS + 1
    564         ));
    565         assert!(!first.exhausted());
    566         assert!(!second.exhausted());
    567         let (raw, event) = original();
    568         assert!(connection.capture(&event_frame("a", &raw)));
    569         assert!(connection.capture(&event_frame("b", &raw)));
    570         drop(a);
    571         drop(first);
    572         assert!(admitted(&connection));
    573         assert_eq!(b.take(&event).as_deref(), Some(raw.as_str()));
    574         assert!(!second.exhausted());
    575         drop(second);
    576         assert!(b.take(&event).is_none());
    577         assert!(admitted(&connection));
    578     }
    579 
    580     #[tokio::test]
    581     async fn live_queue_loss_wakes_a_pending_observer_without_closing_another_scope() {
    582         let registry = registry();
    583         let live = registry
    584             .register_live(["one".to_owned()].into_iter())
    585             .unwrap();
    586         let other = registry
    587             .register_live(["one".to_owned()].into_iter())
    588             .unwrap();
    589         let scope = live.bind_originals("one", "a").unwrap();
    590         let _other_scope = other.bind_originals("one", "b").unwrap();
    591         let connection = registry.connection("one").unwrap();
    592         let (raw, event) = original();
    593         let wait = live.wait_exhausted();
    594         futures::pin_mut!(wait);
    595         assert!(futures::poll!(wait.as_mut()).is_pending());
    596         for _ in 0..crate::source_original::MAX_PENDING_EVENTS {
    597             assert!(connection.capture(&event_frame("a", &raw)));
    598         }
    599         assert!(connection.capture(&event_frame("a", &raw)));
    600         tokio::time::timeout(std::time::Duration::from_secs(1), wait)
    601             .await
    602             .unwrap();
    603         assert!(live.exhausted());
    604         assert!(!other.exhausted());
    605         assert!(admitted(&connection));
    606         assert_eq!(scope.take(&event).as_deref(), Some(raw.as_str()));
    607         // A lost scope cannot resume admission after unrelated dequeueing.
    608         assert!(connection.capture(&event_frame("a", &raw)));
    609         assert!(live.exhausted());
    610     }
    611 
    612     fn registry() -> IngressRegistry {
    613         IngressRegistry::new(["one".to_owned(), "two".to_owned()].into_iter())
    614     }
    615 
    616     fn register(
    617         registry: &IngressRegistry,
    618         targets: &[&str],
    619         budget: &Arc<FetchBudget>,
    620     ) -> IngressRegistration {
    621         registry
    622             .register(
    623                 targets.iter().map(|target| (*target).to_owned()),
    624                 Arc::clone(budget),
    625             )
    626             .unwrap()
    627     }
    628 
    629     fn admitted(connection: &IngressConnection) -> bool {
    630         connection.admitted(&Context::from_waker(futures::task::noop_waker_ref()))
    631     }
    632 
    633     #[test]
    634     fn cancellation_closes_the_exact_generation_and_a_new_fetch_can_reconnect() {
    635         let registry = registry();
    636         let budget = Arc::new(FetchBudget::default());
    637         let registration = register(&registry, &["one"], &budget);
    638         let first = registry.connection("one").unwrap();
    639         assert!(admitted(&first));
    640         drop(registration);
    641         assert!(!admitted(&first));
    642         assert!(!first.charge(1, 1, 1));
    643         let fresh = register(&registry, &["one"], &Arc::new(FetchBudget::default()));
    644         let second = registry.connection("one").unwrap();
    645         assert!(admitted(&second));
    646         assert!(second.charge(1, 1, 1));
    647         assert!(!admitted(&first));
    648         fresh.finish();
    649         assert!(admitted(&second));
    650         assert!(second.charge(MAX_FETCH_BYTES + 1, 0, 0));
    651     }
    652 
    653     #[test]
    654     fn all_batches_and_reconnections_share_one_monotonic_budget() {
    655         let registry = registry();
    656         let budget = Arc::new(FetchBudget::default());
    657         let registration = register(&registry, &["one", "two"], &budget);
    658         let first = registry.connection("one").unwrap();
    659         assert!(first.charge(MAX_FETCH_BYTES / 2, 1, 1));
    660         let retried = registry.connection("one").unwrap();
    661         assert!(!admitted(&first));
    662         assert!(!first.charge(1, 0, 0));
    663         assert!(retried.charge(MAX_FETCH_BYTES / 2, 1, 1));
    664         let second = registry.connection("two").unwrap();
    665         assert!(!second.charge(1, 0, 0));
    666         assert!(budget.exhausted());
    667         assert!(!admitted(&retried));
    668         assert!(!admitted(&second));
    669         drop(registration);
    670         assert!(!admitted(&retried));
    671     }
    672 
    673     #[test]
    674     fn overlapping_fetches_each_charge_shared_traffic_and_unselected_relays_do_not() {
    675         let registry = registry();
    676         let first_budget = Arc::new(FetchBudget::default());
    677         let second_budget = Arc::new(FetchBudget::default());
    678         let first = register(&registry, &["one"], &first_budget);
    679         let second = register(&registry, &["one"], &second_budget);
    680         let other = registry.connection("two").unwrap();
    681         assert!(other.charge(
    682             MAX_FETCH_BYTES + 1,
    683             MAX_FETCH_NOTIFICATIONS + 1,
    684             MAX_FETCH_EVENTS + 1
    685         ));
    686         let connection = registry.connection("one").unwrap();
    687         assert!(connection.charge(MAX_FETCH_BYTES, 0, 0));
    688         first.finish();
    689         assert!(!connection.charge(1, 0, 0));
    690         assert!(!first_budget.exhausted());
    691         assert!(second_budget.exhausted());
    692         assert!(admitted(&other));
    693         drop(second);
    694     }
    695 
    696     #[test]
    697     fn registration_capacity_unknown_targets_and_counter_overflow_fail_closed() {
    698         let registry = registry();
    699         let budget = Arc::new(FetchBudget::default());
    700         assert!(
    701             registry
    702                 .register(["unknown".to_owned()].into_iter(), Arc::clone(&budget))
    703                 .is_none()
    704         );
    705         assert!(registry.connection("unknown").is_none());
    706         let mut registrations = (0..MAX_ACTIVE_SCOPES)
    707             .map(|_| register(&registry, &["one"], &budget))
    708             .collect::<Vec<_>>();
    709         assert!(
    710             registry
    711                 .register(["one".to_owned()].into_iter(), Arc::clone(&budget))
    712                 .is_none()
    713         );
    714         registrations.pop().unwrap().finish();
    715         register(&registry, &["one"], &budget).finish();
    716         for registration in registrations {
    717             registration.finish();
    718         }
    719         registry.0.lock().unwrap().sequence = u64::MAX;
    720         assert!(
    721             registry
    722                 .register(["one".to_owned()].into_iter(), budget)
    723                 .is_none()
    724         );
    725         registry
    726             .0
    727             .lock()
    728             .unwrap()
    729             .relays
    730             .get_mut("one")
    731             .unwrap()
    732             .generation = u64::MAX;
    733         assert!(registry.connection("one").is_none());
    734     }
    735 
    736     #[test]
    737     fn cancel_notifies_the_pending_reader() {
    738         struct Wake(std::sync::atomic::AtomicBool);
    739         impl futures::task::ArcWake for Wake {
    740             fn wake_by_ref(arc_self: &Arc<Self>) {
    741                 arc_self.0.store(true, std::sync::atomic::Ordering::SeqCst);
    742             }
    743         }
    744         let registry = registry();
    745         let registration = register(&registry, &["one"], &Arc::new(FetchBudget::default()));
    746         let connection = registry.connection("one").unwrap();
    747         let wake = Arc::new(Wake(std::sync::atomic::AtomicBool::new(false)));
    748         let waker = futures::task::waker(Arc::clone(&wake));
    749         assert!(connection.admitted(&Context::from_waker(&waker)));
    750         drop(registration);
    751         assert!(wake.0.load(std::sync::atomic::Ordering::SeqCst));
    752         assert!(!admitted(&connection));
    753     }
    754 
    755     #[test]
    756     fn a_stale_generation_cannot_steal_live_reader_or_writer_wakeups() {
    757         struct Wake(std::sync::atomic::AtomicBool);
    758         impl futures::task::ArcWake for Wake {
    759             fn wake_by_ref(arc_self: &Arc<Self>) {
    760                 arc_self.0.store(true, std::sync::atomic::Ordering::SeqCst);
    761             }
    762         }
    763         let registry = registry();
    764         let registration = register(&registry, &["one"], &Arc::new(FetchBudget::default()));
    765         let stale = registry.connection("one").unwrap();
    766         let current = registry.connection("one").unwrap();
    767         let read = Arc::new(Wake(std::sync::atomic::AtomicBool::new(false)));
    768         let write = Arc::new(Wake(std::sync::atomic::AtomicBool::new(false)));
    769         let read_waker = futures::task::waker(Arc::clone(&read));
    770         let write_waker = futures::task::waker(Arc::clone(&write));
    771         assert!(current.admitted(&Context::from_waker(&read_waker)));
    772         assert!(current.admitted_write(&Context::from_waker(&write_waker)));
    773         assert!(!stale.admitted(&Context::from_waker(futures::task::noop_waker_ref())));
    774         assert!(!stale.admitted_write(&Context::from_waker(futures::task::noop_waker_ref())));
    775         drop(registration);
    776         assert!(read.0.load(std::sync::atomic::Ordering::SeqCst));
    777         assert!(write.0.load(std::sync::atomic::Ordering::SeqCst));
    778     }
    779 
    780     #[test]
    781     fn finalization_and_ingress_have_one_ordered_completion_boundary() {
    782         for ingress_first in [false, true] {
    783             let registry = registry();
    784             let budget = Arc::new(FetchBudget::default());
    785             let registration = register(&registry, &["one"], &budget);
    786             let connection = registry.connection("one").unwrap();
    787             assert!(connection.charge(MAX_FETCH_BYTES, 0, 0));
    788             if ingress_first {
    789                 assert!(!connection.charge(1, 0, 0));
    790                 assert!(!registration.finish());
    791                 assert!(budget.exhausted());
    792                 assert!(!admitted(&connection));
    793             } else {
    794                 assert!(registration.finish());
    795                 assert!(connection.charge(1, 0, 0));
    796                 assert!(!budget.exhausted());
    797                 assert!(admitted(&connection));
    798             }
    799             assert!(registry.0.lock().unwrap().active.is_empty());
    800         }
    801     }
    802 
    803     #[test]
    804     fn racing_completion_and_last_byte_cannot_both_claim_admission() {
    805         for _ in 0..32 {
    806             let registry = registry();
    807             let budget = Arc::new(FetchBudget::default());
    808             let registration = register(&registry, &["one"], &budget);
    809             let connection = registry.connection("one").unwrap();
    810             assert!(connection.charge(MAX_FETCH_BYTES, 0, 0));
    811             let barrier = std::sync::Barrier::new(2);
    812             let (complete, admitted_after_limit) = std::thread::scope(|scope| {
    813                 let finish = scope.spawn(|| {
    814                     barrier.wait();
    815                     registration.finish()
    816                 });
    817                 barrier.wait();
    818                 let admitted_after_limit = connection.charge(1, 0, 0);
    819                 (finish.join().unwrap(), admitted_after_limit)
    820             });
    821             assert_eq!(complete, admitted_after_limit);
    822             assert_eq!(budget.exhausted(), !complete);
    823         }
    824     }
    825 
    826     #[test]
    827     fn missing_or_poisoned_registration_cannot_finalize_successfully() {
    828         let registry = registry();
    829         let budget = Arc::new(FetchBudget::default());
    830         let missing = register(&registry, &["one"], &budget);
    831         registry.0.lock().unwrap().active.remove(&missing.id);
    832         assert!(!missing.finish());
    833         let poisoned = register(&registry, &["one"], &budget);
    834         let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
    835             let _guard = registry.0.lock().unwrap();
    836             panic!("poison the registration lock");
    837         }));
    838         assert!(!poisoned.finish());
    839     }
    840 
    841     #[test]
    842     fn missing_or_poisoned_connection_state_refuses_both_io_directions_and_charging() {
    843         let registry = registry();
    844         let missing = IngressConnection {
    845             registry: registry.clone(),
    846             relay: "missing".into(),
    847             generation: 1,
    848         };
    849         let context = Context::from_waker(futures::task::noop_waker_ref());
    850         assert!(!missing.admitted(&context));
    851         assert!(!missing.admitted_write(&context));
    852         assert!(!missing.charge(0, 0, 0));
    853         let current = registry.connection("one").unwrap();
    854         assert!(current.admitted(&context));
    855         let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
    856             let _guard = registry.0.lock().unwrap();
    857             panic!("injected connection registry failure");
    858         }));
    859         assert!(!current.admitted(&context));
    860         assert!(!current.admitted_write(&context));
    861         assert!(!current.charge(1, 1, 1));
    862         assert!(registry.connection("one").is_none());
    863         assert!(
    864             registry
    865                 .register(
    866                     ["one".to_owned()].into_iter(),
    867                     Arc::new(FetchBudget::default())
    868                 )
    869                 .is_none()
    870         );
    871     }
    872 }