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(®istry, &["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(®istry, &["one"], &Arc::new(FetchBudget::default())); 467 let second = register(®istry, &["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(®istry, &["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(®istry, &["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(®istry, &["one"], &a_budget); 516 let b = register(®istry, &["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(®istry, &["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(®istry, &["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(®istry, &["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(®istry, &["one"], &first_budget); 679 let second = register(®istry, &["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(®istry, &["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(®istry, &["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(®istry, &["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(®istry, &["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(®istry, &["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(®istry, &["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(®istry, &["one"], &budget); 831 registry.0.lock().unwrap().active.remove(&missing.id); 832 assert!(!missing.finish()); 833 let poisoned = register(®istry, &["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 }