source.rs (81363B)
1 //! Nostr implementation of the transport event source. 2 3 use crate::host_time::unix_time_ms; 4 use crate::{NostrTransport, RelayCursor, RelayUrl, status}; 5 use core::cmp::Ordering; 6 use core::time::Duration; 7 use futures::{Stream, StreamExt, stream}; 8 use nostr_sdk::prelude::{ 9 Filter, Kind, PublicKey, RelayMessage, RelayNotification, ReqExitPolicy, SingleLetterTag, 10 SubscribeAutoCloseOptions, SubscriptionId, Timestamp, 11 }; 12 use radroots_transport::{ 13 BoxFuture, EventSource, FetchPage, FetchRequest, 14 outcome::{FetchTargetOutcome, FetchTargetState}, 15 source::{EventProvenance, FetchCursor, NextPage, ObservedEvent, SourceStatus}, 16 }; 17 use sha2::{Digest, Sha256}; 18 use std::collections::{BTreeMap, BTreeSet}; 19 use std::sync::Arc; 20 21 #[path = "source_budget.rs"] 22 pub(crate) mod budget; 23 use budget::FetchBudget; 24 25 #[path = "source_window.rs"] 26 mod window; 27 28 #[cfg(test)] 29 #[path = "source_paging_tests.rs"] 30 mod paging_tests; 31 32 #[cfg(test)] 33 #[path = "source_original_tests.rs"] 34 mod original_tests; 35 36 const UPSTREAM_FETCH_LIMIT: usize = 1_000; 37 38 pub(crate) fn observed_limits() -> radroots_event_codec::decode::EventWireLimits { 39 let maximum = radroots_protocol::profile::SIGNED_EVENT_MAX_BYTES; 40 radroots_event_codec::decode::EventWireLimits { 41 max_raw_json_bytes: maximum, 42 max_content_bytes: maximum, 43 max_tag_element_bytes: maximum, 44 max_total_tag_bytes: maximum, 45 ..Default::default() 46 } 47 } 48 const CURSOR_PREFIX: &str = "nostr-v2"; 49 const CURSOR_SCOPE_DOMAIN: &[u8] = b"radroots.transport-nostr.fetch-cursor.v2\0"; 50 51 #[derive(Clone, Debug)] 52 pub(crate) struct SourceQuery { 53 relays: Vec<RelayUrl>, 54 selector: radroots_transport::source::FetchSelector, 55 until_unix_seconds: Option<u64>, 56 connect_timeout: Duration, 57 deadline: crate::host_time::Instant, 58 max_connections: usize, 59 } 60 61 #[derive(Clone, Debug)] 62 pub(crate) struct RelayFetchBatch { 63 relay: RelayUrl, 64 result: RelayFetchResult, 65 } 66 67 #[derive(Clone, Debug, PartialEq, Eq)] 68 pub(crate) enum RelayFetchResult { 69 Complete(Vec<String>), 70 Timeout(Vec<String>), 71 ResourceLimit(Vec<String>), 72 Failed(String), 73 } 74 75 pub(crate) trait RelaySourceClient: Send + Sync { 76 fn fetch<'a>(&'a self, query: SourceQuery) -> BoxFuture<'a, Vec<RelayFetchBatch>>; 77 } 78 79 #[derive(Clone, Debug)] 80 pub(crate) struct LiveRelaySourceClient { 81 client: nostr_sdk::client::Client, 82 ingress: crate::source_ingress::IngressRegistry, 83 connections: Arc<crate::connections::Connections>, 84 } 85 86 impl LiveRelaySourceClient { 87 pub(crate) const fn new( 88 client: nostr_sdk::client::Client, 89 ingress: crate::source_ingress::IngressRegistry, 90 connections: Arc<crate::connections::Connections>, 91 ) -> Self { 92 Self { 93 client, 94 ingress, 95 connections, 96 } 97 } 98 99 #[cfg(test)] 100 pub(crate) fn isolated() -> Self { 101 let client = nostr_sdk::client::Client::default(); 102 Self::new( 103 client, 104 crate::source_ingress::IngressRegistry::default(), 105 Arc::new(crate::connections::Connections::new( 106 crate::client::MAX_RELAYS, 107 )), 108 ) 109 } 110 } 111 112 impl RelaySourceClient for LiveRelaySourceClient { 113 // The live SDK loop is exercised by bounded loopback regressions; injected 114 // source tests independently cover selection and normalized results. 115 #[cfg_attr(coverage_nightly, coverage(off))] 116 fn fetch<'a>(&'a self, query: SourceQuery) -> BoxFuture<'a, Vec<RelayFetchBatch>> { 117 Box::pin(async move { 118 let SourceQuery { 119 relays, 120 selector, 121 until_unix_seconds, 122 connect_timeout, 123 deadline, 124 max_connections, 125 } = query; 126 let budget = Arc::new(FetchBudget::default()); 127 // An unencodable selector has no network work or ingress to admit. 128 if !selector.kinds().is_empty() 129 && selector 130 .kinds() 131 .iter() 132 .all(|kind| u16::try_from(*kind).is_err()) 133 { 134 return relays 135 .into_iter() 136 .map(|relay| RelayFetchBatch { 137 relay, 138 result: RelayFetchResult::Complete(Vec::new()), 139 }) 140 .collect(); 141 } 142 let connections = match admit_fetch_connections(&self.client, &relays, deadline).await { 143 Ok(connections) => connections, 144 Err(result) => { 145 return relays 146 .into_iter() 147 .map(|relay| RelayFetchBatch { 148 relay, 149 result: result.clone(), 150 }) 151 .collect(); 152 } 153 }; 154 let registration = self.ingress.register( 155 relays.iter().map(|relay| relay.as_str().to_owned()), 156 Arc::clone(&budget), 157 ); 158 let Some(registration) = registration else { 159 // No ingress or query I/O was admitted, so existing shared 160 // connections retain their previous operation ownership. 161 connections.finish(); 162 return relays 163 .into_iter() 164 .map(|relay| RelayFetchBatch { 165 relay, 166 result: RelayFetchResult::ResourceLimit(Vec::new()), 167 }) 168 .collect(); 169 }; 170 let mut batches: Vec<RelayFetchBatch> = stream::iter(relays.into_iter().map(|relay| { 171 let selector = selector.clone(); 172 let budget = Arc::clone(&budget); 173 let registration = ®istration; 174 async move { 175 let url = relay.as_str().to_owned(); 176 let result = async { 177 if budget.exhausted() { 178 return Ok(RelayFetchResult::ResourceLimit(Vec::new())); 179 } 180 if crate::host_time::Instant::now() >= deadline { 181 return Ok(RelayFetchResult::Timeout(Vec::new())); 182 } 183 let kinds = selector 184 .kinds() 185 .iter() 186 .filter_map(|kind| u16::try_from(*kind).ok()) 187 .map(Kind::from) 188 .collect::<Vec<_>>(); 189 let authors = selector 190 .authors() 191 .iter() 192 .filter_map(|author| PublicKey::from_slice(author.as_bytes()).ok()) 193 .collect::<Vec<_>>(); 194 if authors.len() != selector.authors().len() { 195 return Ok(RelayFetchResult::Complete(Vec::new())); 196 } 197 let mut filter = Filter::new().limit(UPSTREAM_FETCH_LIMIT); 198 if !kinds.is_empty() { 199 filter = filter.kinds(kinds); 200 } 201 if !authors.is_empty() { 202 filter = filter.authors(authors); 203 } 204 filter = apply_exact_tag_filters(filter, &selector).map_err(|()| { 205 String::from("validated indexed tag cannot be encoded") 206 })?; 207 if let Some(since) = selector.since_unix_seconds() { 208 filter = filter.since(Timestamp::from_secs(since)); 209 } 210 if let Some(until) = until_unix_seconds { 211 filter = filter.until(Timestamp::from_secs(until)); 212 } 213 let connected = crate::host_time::timeout_at(deadline, async { 214 crate::client::connect_tracked( 215 &self.client, 216 &self.connections, 217 url.as_str(), 218 connect_timeout.min(deadline.saturating_duration_since( 219 crate::host_time::Instant::now(), 220 )), 221 ) 222 .await 223 .map_err(|error| error.to_string()) 224 }) 225 .await; 226 let relay = match connected { 227 Ok(result) => result?, 228 Err(_) => return Ok(RelayFetchResult::Timeout(Vec::new())), 229 }; 230 let mut notifications = relay 231 .notifications() 232 .with_gaps() 233 .map(|item| item.map_err(|_| ())); 234 let subscription_id = SubscriptionId::generate(); 235 let Some(originals) = 236 registration.bind_originals(&url, subscription_id.as_str()) 237 else { 238 return Ok(RelayFetchResult::ResourceLimit(Vec::new())); 239 }; 240 let remaining = 241 deadline.saturating_duration_since(crate::host_time::Instant::now()); 242 if remaining.is_zero() { 243 return Ok(RelayFetchResult::Timeout(Vec::new())); 244 } 245 let options = SubscribeAutoCloseOptions::default() 246 .exit_policy(ReqExitPolicy::ExitOnEOSE) 247 .timeout(Some(remaining)); 248 match crate::host_time::timeout_at( 249 deadline, 250 relay 251 .subscribe(filter) 252 .with_id(subscription_id.clone()) 253 .close_on(options), 254 ) 255 .await 256 { 257 Ok(result) => { 258 result.map_err(|error| error.to_string())?; 259 } 260 Err(_) => return Ok(RelayFetchResult::Timeout(Vec::new())), 261 } 262 let result = collect_until_eose( 263 &mut notifications, 264 &subscription_id, 265 deadline, 266 &budget, 267 |event| originals.take(event), 268 ) 269 .await; 270 Ok(result) 271 } 272 .await; 273 RelayFetchBatch { 274 relay, 275 result: match result { 276 Err(_) if budget.exhausted() => { 277 RelayFetchResult::ResourceLimit(Vec::new()) 278 } 279 Ok(RelayFetchResult::Timeout(events)) if budget.exhausted() => { 280 RelayFetchResult::ResourceLimit(events) 281 } 282 result => result.unwrap_or_else(RelayFetchResult::Failed), 283 }, 284 } 285 } 286 })) 287 .buffered(max_connections) 288 .collect() 289 .await; 290 if finish_fetch(&mut batches, registration) { 291 connections.finish(); 292 } 293 batches 294 }) 295 } 296 } 297 298 async fn admit_fetch_connections( 299 client: &nostr_sdk::client::Client, 300 relays: &[RelayUrl], 301 deadline: crate::host_time::Instant, 302 ) -> Result<FetchConnections, RelayFetchResult> { 303 let connections = FetchConnections::default(); 304 let admitted = crate::host_time::timeout_at(deadline, async { 305 for relay in relays { 306 if crate::host_time::Instant::now() >= deadline { 307 return Err(RelayFetchResult::Timeout(Vec::new())); 308 } 309 // Adding a relay is inert SDK metadata admission, not connection 310 // work. Own even preexisting queued sockets before ingress can be 311 // revoked by this fetch's registration. 312 client 313 .add_relay(relay.as_str()) 314 .await 315 .map_err(|error| RelayFetchResult::Failed(error.to_string()))?; 316 connections 317 .retain( 318 client 319 .relay(relay.as_str()) 320 .await 321 .map_err(|error| RelayFetchResult::Failed(error.to_string()))? 322 .ok_or_else(|| { 323 RelayFetchResult::Failed(String::from( 324 "configured relay is unavailable", 325 )) 326 })?, 327 ) 328 .map_err(RelayFetchResult::Failed)?; 329 } 330 if crate::host_time::Instant::now() >= deadline { 331 Err(RelayFetchResult::Timeout(Vec::new())) 332 } else { 333 Ok(()) 334 } 335 }) 336 .await; 337 match admitted { 338 Ok(Ok(())) => Ok(connections), 339 Ok(Err(result)) => Err(result), 340 Err(_) => Err(RelayFetchResult::Timeout(Vec::new())), 341 } 342 } 343 344 fn finish_fetch( 345 batches: &mut [RelayFetchBatch], 346 registration: crate::source_ingress::IngressRegistration, 347 ) -> bool { 348 if !batches 349 .iter() 350 .all(|batch| matches!(batch.result, RelayFetchResult::Complete(_))) 351 { 352 return false; 353 } 354 if registration.finish() { 355 return true; 356 } 357 // Earlier EOSE evidence remains useful, but finalization cannot declare 358 // an entirely complete fetch after ingress exhausted its shared budget. 359 if let Some(last) = batches.last_mut() 360 && let RelayFetchResult::Complete(events) = &mut last.result 361 { 362 last.result = RelayFetchResult::ResourceLimit(std::mem::take(events)); 363 } 364 false 365 } 366 367 // The SDK owns its socket tasks. Its synchronous disconnect signal disables 368 // reconnect and tears down those tasks, including when the fetch future drops. 369 #[derive(Default)] 370 struct FetchConnections(std::sync::Mutex<Vec<nostr_sdk::relay::Relay>>); 371 372 impl FetchConnections { 373 fn retain(&self, relay: nostr_sdk::relay::Relay) -> Result<(), String> { 374 self.0 375 .lock() 376 .map_err(|_| String::from("fetch connection state unavailable"))? 377 .push(relay); 378 Ok(()) 379 } 380 381 fn finish(&self) { 382 if let Ok(mut relays) = self.0.lock() { 383 relays.clear(); 384 } 385 } 386 } 387 388 impl Drop for FetchConnections { 389 fn drop(&mut self) { 390 let relays = self 391 .0 392 .get_mut() 393 .unwrap_or_else(std::sync::PoisonError::into_inner); 394 for relay in relays { 395 relay.disconnect(); 396 } 397 } 398 } 399 400 async fn collect_until_eose( 401 notifications: &mut (impl Stream<Item = Result<RelayNotification, ()>> + Unpin), 402 subscription_id: &SubscriptionId, 403 deadline: crate::host_time::Instant, 404 budget: &FetchBudget, 405 mut original: impl FnMut(&nostr_sdk::prelude::Event) -> Option<String>, 406 ) -> RelayFetchResult { 407 let mut events = Vec::new(); 408 loop { 409 if budget.exhausted() { 410 return RelayFetchResult::ResourceLimit(events); 411 } 412 if crate::host_time::Instant::now() >= deadline { 413 return RelayFetchResult::Timeout(events); 414 } 415 let received = tokio::select! { 416 biased; 417 _ = budget.wait_exhausted() => return RelayFetchResult::ResourceLimit(events), 418 received = crate::host_time::timeout_at(deadline, notifications.next()) => received, 419 }; 420 let notification = match received { 421 Ok(Some(Ok(notification))) => notification, 422 Ok(Some(Err(()))) => { 423 return RelayFetchResult::Failed(String::from("relay notification gap")); 424 } 425 Ok(None) => { 426 return RelayFetchResult::Failed(String::from("relay notifications unavailable")); 427 } 428 Err(_) => return RelayFetchResult::Timeout(events), 429 }; 430 if !budget.notification() { 431 return RelayFetchResult::ResourceLimit(events); 432 } 433 match notification { 434 RelayNotification::Message { message } => match *message { 435 RelayMessage::Event { 436 subscription_id: observed_subscription, 437 event, 438 } if observed_subscription.as_ref() == subscription_id => { 439 if events.len() >= UPSTREAM_FETCH_LIMIT { 440 return RelayFetchResult::ResourceLimit(events); 441 } 442 let Some(raw) = original(event.as_ref()) else { 443 // A parsed notification cannot recreate lost original 444 // evidence. Preserve partial results and require recovery. 445 return RelayFetchResult::ResourceLimit(events); 446 }; 447 if !budget.event(raw.len()) { 448 return RelayFetchResult::ResourceLimit(events); 449 } 450 events.push(raw); 451 } 452 RelayMessage::EndOfStoredEvents(observed_subscription) 453 if observed_subscription.as_ref() == subscription_id => 454 { 455 return if budget.exhausted() { 456 RelayFetchResult::ResourceLimit(events) 457 } else if crate::host_time::Instant::now() < deadline { 458 RelayFetchResult::Complete(events) 459 } else { 460 RelayFetchResult::Timeout(events) 461 }; 462 } 463 RelayMessage::Closed { 464 subscription_id: observed_subscription, 465 message, 466 } if observed_subscription.as_ref() == subscription_id => { 467 return RelayFetchResult::Failed(message.into_owned()); 468 } 469 _ => {} 470 }, 471 RelayNotification::RelayStatus { 472 status: 473 nostr_sdk::prelude::RelayStatus::Disconnected 474 | nostr_sdk::prelude::RelayStatus::Idle 475 | nostr_sdk::prelude::RelayStatus::Banned, 476 } => { 477 return RelayFetchResult::Failed(String::from("relay disconnected")); 478 } 479 RelayNotification::AuthenticationFailed => { 480 return RelayFetchResult::Failed(String::from("relay authentication failed")); 481 } 482 RelayNotification::RelayStatus { 483 status: nostr_sdk::prelude::RelayStatus::Shutdown, 484 } => { 485 return RelayFetchResult::Failed(String::from("relay shutdown")); 486 } 487 _ => {} 488 } 489 } 490 } 491 492 #[derive(Debug)] 493 struct Candidate { 494 relay: RelayUrl, 495 raw: String, 496 created_at: u64, 497 event_id: String, 498 } 499 500 impl EventSource for NostrTransport { 501 fn status(&self) -> BoxFuture<'_, Result<SourceStatus, radroots_transport::Error>> { 502 Box::pin(async move { 503 self.require_open()?; 504 Ok(status::source_status(&self.status)) 505 }) 506 } 507 508 fn fetch( 509 &self, 510 request: FetchRequest, 511 ) -> BoxFuture<'_, Result<FetchPage, radroots_transport::Error>> { 512 Box::pin(async move { 513 let _operation = self.connections.begin()?; 514 let cursor_scope = request_scope(&request); 515 let cursor = request 516 .cursor() 517 .map(|cursor| window::Position::parse(cursor, cursor_scope.as_str())) 518 .transpose()?; 519 let effective_until = 520 window::effective_until(request.selector().until_unix_seconds(), cursor.as_ref()); 521 let now_ms = unix_time_ms(); 522 let remaining_ms = request.bounds().deadline_unix_ms().saturating_sub(now_ms); 523 let timeout_ms = remaining_ms.min(self.config().request_timeout_ms()); 524 let deadline = crate::host_time::Instant::now() + Duration::from_millis(timeout_ms); 525 526 let mut targets = BTreeMap::new(); 527 let mut outcomes = Vec::new(); 528 for target in request.target_set().targets() { 529 match self.config().endpoint_for_target(target) { 530 Some(endpoint) if endpoint.access().can_read() => { 531 let relay = endpoint.url().clone(); 532 if self.status.may_read(&relay, now_ms) { 533 targets.insert(relay, target.clone()); 534 } else { 535 outcomes.push( 536 FetchTargetOutcome::new( 537 target.fingerprint().clone(), 538 FetchTargetState::FailedRetryable, 539 ) 540 .with_message("relay reconnect backoff is active"), 541 ); 542 } 543 } 544 None | Some(_) => outcomes.push( 545 FetchTargetOutcome::new( 546 target.fingerprint().clone(), 547 FetchTargetState::FailedTerminal, 548 ) 549 .with_message("target is not configured for this source"), 550 ), 551 } 552 } 553 554 if timeout_ms == 0 { 555 for relay in targets.keys() { 556 self.status.record_read(relay, false, true, now_ms); 557 } 558 outcomes.extend(targets.values().map(|target| { 559 FetchTargetOutcome::new( 560 target.fingerprint().clone(), 561 FetchTargetState::Cancelled, 562 ) 563 .with_message("fetch deadline elapsed before relay access") 564 })); 565 return FetchPage::for_request(&request, Vec::new(), outcomes, NextPage::Complete); 566 } 567 568 for relay in targets.keys() { 569 self.status.begin_read(relay, now_ms); 570 } 571 let batches = self 572 .source_client 573 .fetch(SourceQuery { 574 relays: targets.keys().cloned().collect(), 575 selector: request.selector().clone(), 576 until_unix_seconds: effective_until, 577 connect_timeout: Duration::from_millis( 578 timeout_ms.min(self.config().connect_timeout_ms()), 579 ), 580 deadline, 581 max_connections: self.config().max_connections(), 582 }) 583 .await; 584 let mut candidates = Vec::new(); 585 let mut capped_window = false; 586 let mut older_boundary = None; 587 let parse_budget = FetchBudget::default(); 588 let mut malformed_by_relay = BTreeMap::<RelayUrl, usize>::new(); 589 let mut reported = BTreeSet::new(); 590 let observed_at_unix_ms = unix_time_ms().max(now_ms); 591 for batch in batches { 592 let RelayFetchBatch { relay, result } = batch; 593 let Some(target) = targets.get(&relay) else { 594 return Err(radroots_transport::Error::UnexpectedFetchTargetOutcome); 595 }; 596 if !reported.insert(relay.clone()) { 597 return Err(radroots_transport::Error::DuplicateFetchTargetOutcome); 598 } 599 let (raw_events, mut terminal) = match result { 600 RelayFetchResult::Complete(events) => (events, FetchTargetState::Complete), 601 RelayFetchResult::Timeout(events) => (events, FetchTargetState::Cancelled), 602 RelayFetchResult::ResourceLimit(events) => (events, FetchTargetState::Partial), 603 RelayFetchResult::Failed(message) => { 604 let (state, safe) = status::fetch_failure(message.as_str()); 605 self.status.record_read( 606 &relay, 607 false, 608 state.is_retryable(), 609 observed_at_unix_ms, 610 ); 611 outcomes.push( 612 FetchTargetOutcome::new(target.fingerprint().clone(), state) 613 .with_message(safe), 614 ); 615 continue; 616 } 617 }; 618 let capped_eose = terminal == FetchTargetState::Complete 619 && raw_events.len() >= UPSTREAM_FETCH_LIMIT; 620 capped_window |= capped_eose; 621 let mut oldest_matching = None; 622 for (index, raw) in raw_events.into_iter().enumerate() { 623 if index >= UPSTREAM_FETCH_LIMIT || !parse_budget.event(raw.len()) { 624 if terminal != FetchTargetState::Cancelled { 625 terminal = FetchTargetState::Partial; 626 } 627 break; 628 } 629 match radroots_event_codec::decode::signed_event_with_limits( 630 raw.as_str(), 631 observed_limits(), 632 ) { 633 Ok(event) 634 if request.selector().matches(&event) 635 && effective_until 636 .is_none_or(|until| event.created_at() <= until) => 637 { 638 oldest_matching = 639 Some(oldest_matching.map_or(event.created_at(), |oldest: u64| { 640 oldest.min(event.created_at()) 641 })); 642 candidates.push(Candidate { 643 relay: relay.clone(), 644 created_at: event.created_at(), 645 event_id: event.id_str().to_owned(), 646 raw, 647 }) 648 } 649 Ok(_) => {} 650 Err(_) => { 651 *malformed_by_relay.entry(relay.clone()).or_default() += 1; 652 } 653 } 654 } 655 if capped_eose && let Some(oldest) = oldest_matching { 656 older_boundary = 657 Some(older_boundary.map_or(oldest, |boundary: u64| boundary.max(oldest))); 658 } 659 // A capped EOSE proves relay availability, while the page's 660 // coverage stays partial. It must not start reconnect backoff. 661 self.status.record_read( 662 &relay, 663 terminal == FetchTargetState::Complete, 664 terminal != FetchTargetState::Complete, 665 observed_at_unix_ms, 666 ); 667 let malformed = malformed_by_relay.get(&relay).copied().unwrap_or_default(); 668 let outcome = if terminal == FetchTargetState::Cancelled { 669 FetchTargetOutcome::new( 670 target.fingerprint().clone(), 671 FetchTargetState::Cancelled, 672 ) 673 .with_message("relay fetch deadline elapsed before EOSE") 674 } else if terminal == FetchTargetState::Partial || capped_eose { 675 FetchTargetOutcome::new(target.fingerprint().clone(), FetchTargetState::Partial) 676 .with_message("relay result reached the bounded fetch inventory") 677 } else if malformed == 0 { 678 FetchTargetOutcome::new( 679 target.fingerprint().clone(), 680 FetchTargetState::Complete, 681 ) 682 } else { 683 FetchTargetOutcome::new(target.fingerprint().clone(), FetchTargetState::Partial) 684 .with_message(format!("ignored {malformed} malformed relay event(s)")) 685 }; 686 outcomes.push(outcome); 687 } 688 for (relay, target) in &targets { 689 if !reported.contains(relay) { 690 self.status 691 .record_read(relay, false, true, observed_at_unix_ms); 692 outcomes.push( 693 FetchTargetOutcome::new( 694 target.fingerprint().clone(), 695 FetchTargetState::FailedRetryable, 696 ) 697 .with_message("relay returned no fetch result"), 698 ); 699 } 700 } 701 candidates.sort_by(compare_candidate); 702 if let Some(cursor) = &cursor { 703 candidates.retain(|candidate| cursor.includes(candidate)); 704 } 705 let mut seen = BTreeSet::new(); 706 candidates.retain(|candidate| seen.insert(candidate.event_id.clone())); 707 708 let has_more = candidates.len() > usize::from(request.bounds().limit()); 709 candidates.truncate(usize::from(request.bounds().limit())); 710 let next_page = if has_more { 711 let last = candidates.last().expect("non-empty bounded page"); 712 NextPage::Cursor(FetchCursor::parse(format!( 713 "{CURSOR_PREFIX}:{}:{}:{cursor_scope}", 714 last.created_at, last.event_id, 715 ))?) 716 } else if capped_window { 717 NextPage::Cancelled { 718 resume_from: older_boundary 719 .and_then(|boundary| window::before_boundary(boundary, &cursor_scope)), 720 } 721 } else { 722 NextPage::Complete 723 }; 724 let observed_at = unix_time_ms().max(1); 725 let mut events = Vec::with_capacity(candidates.len()); 726 for candidate in candidates { 727 let target = targets 728 .get(&candidate.relay) 729 .expect("candidate relay has requested target"); 730 let mut provenance = EventProvenance::new( 731 radroots_transport::TransportId::NOSTR, 732 target.fingerprint().clone(), 733 observed_at, 734 )?; 735 if let Some(request_cursor) = request.cursor().cloned() { 736 provenance = provenance.with_cursor(request_cursor); 737 } 738 let event = radroots_event_codec::decode::signed_event_with_limits( 739 candidate.raw.as_str(), 740 observed_limits(), 741 ) 742 .map_err(|_| radroots_transport::Error::UnexpectedFetchProvenance)?; 743 events.push(ObservedEvent::new(event, provenance)); 744 } 745 FetchPage::for_request(&request, events, outcomes, next_page) 746 }) 747 } 748 } 749 750 fn parse_cursor( 751 cursor: &FetchCursor, 752 expected_scope: &str, 753 ) -> Result<RelayCursor, radroots_transport::Error> { 754 let mut parts = cursor.as_str().split(':'); 755 let valid = parts.next() == Some(CURSOR_PREFIX); 756 let created_at = parts.next().and_then(|value| value.parse::<u64>().ok()); 757 let event_id = parts.next(); 758 let scope = parts.next(); 759 if !valid || parts.next().is_some() { 760 return Err(radroots_transport::Error::InvalidFetchCursor); 761 } 762 let (Some(created_at), Some(event_id), Some(scope)) = (created_at, event_id, scope) else { 763 return Err(radroots_transport::Error::InvalidFetchCursor); 764 }; 765 if scope != expected_scope { 766 return Err(radroots_transport::Error::InvalidFetchCursor); 767 } 768 RelayCursor::new(created_at, event_id) 769 .map_err(|_| radroots_transport::Error::InvalidFetchCursor) 770 } 771 772 fn compare_candidate(left: &Candidate, right: &Candidate) -> Ordering { 773 right 774 .created_at 775 .cmp(&left.created_at) 776 .then_with(|| right.event_id.cmp(&left.event_id)) 777 .then_with(|| left.relay.cmp(&right.relay)) 778 } 779 780 fn candidate_is_after_cursor(candidate: &Candidate, cursor: &RelayCursor) -> bool { 781 cursor.page_precedes(candidate.created_at, candidate.event_id.as_str()) 782 } 783 784 fn request_scope(request: &FetchRequest) -> String { 785 let mut hasher = Sha256::new(); 786 hasher.update(CURSOR_SCOPE_DOMAIN); 787 for target in request.target_set().targets() { 788 hasher.update(target.fingerprint().as_str().as_bytes()); 789 hasher.update([0]); 790 } 791 for kind in request.selector().kinds() { 792 hasher.update(kind.to_be_bytes()); 793 } 794 hasher.update([0]); 795 for author in request.selector().authors() { 796 hasher.update(author.as_bytes()); 797 } 798 hasher.update([0]); 799 hash_exact_tag_filters(&mut hasher, request.selector()); 800 hash_optional_u64(&mut hasher, request.selector().since_unix_seconds()); 801 hash_optional_u64(&mut hasher, request.selector().until_unix_seconds()); 802 hex_encode(&hasher.finalize()) 803 } 804 805 pub(crate) fn hash_exact_tag_filters( 806 hasher: &mut Sha256, 807 selector: &radroots_transport::source::FetchSelector, 808 ) { 809 let mut filters = selector.exact_tag_filters().peekable(); 810 if filters.peek().is_none() { 811 return; 812 } 813 hasher.update([2]); 814 for (key, values) in filters { 815 hasher.update([u8::try_from(key).expect("validated ASCII tag key")]); 816 hasher.update( 817 u64::try_from(values.len()) 818 .expect("bounded tag-value count") 819 .to_be_bytes(), 820 ); 821 for value in values { 822 hasher.update( 823 u64::try_from(value.len()) 824 .expect("bounded tag-value length") 825 .to_be_bytes(), 826 ); 827 hasher.update(value.as_bytes()); 828 } 829 } 830 hasher.update([0]); 831 } 832 833 pub(crate) fn apply_exact_tag_filters( 834 mut filter: Filter, 835 selector: &radroots_transport::source::FetchSelector, 836 ) -> Result<Filter, ()> { 837 for (key, values) in selector.exact_tag_filters() { 838 let tag = SingleLetterTag::from_char(key).map_err(|_| ())?; 839 filter = filter.custom_tags(tag, values.iter().map(String::as_str)); 840 } 841 Ok(filter) 842 } 843 844 fn hash_optional_u64(hasher: &mut Sha256, value: Option<u64>) { 845 match value { 846 Some(value) => { 847 hasher.update([1]); 848 hasher.update(value.to_be_bytes()); 849 } 850 None => hasher.update([0]), 851 } 852 } 853 854 fn hex_encode(bytes: &[u8]) -> String { 855 const HEX: &[u8; 16] = b"0123456789abcdef"; 856 let mut encoded = String::with_capacity(bytes.len() * 2); 857 for byte in bytes { 858 encoded.push(HEX[(byte >> 4) as usize] as char); 859 encoded.push(HEX[(byte & 0x0f) as usize] as char); 860 } 861 encoded 862 } 863 864 #[cfg(test)] 865 mod tests { 866 use super::*; 867 use crate::{Config, RelayUrlPolicy}; 868 use radroots_transport::{ 869 FetchRequest, Target, TargetSet, 870 source::{FetchBounds, FetchSelector, NextPage}, 871 }; 872 use std::borrow::Cow; 873 use std::sync::{ 874 Arc, 875 atomic::{AtomicUsize, Ordering as AtomicOrdering}, 876 }; 877 878 async fn collect_until_eose_test( 879 notifications: &mut (impl Stream<Item = Result<RelayNotification, ()>> + Unpin), 880 subscription_id: &SubscriptionId, 881 deadline: crate::host_time::Instant, 882 budget: &FetchBudget, 883 ) -> RelayFetchResult { 884 collect_until_eose(notifications, subscription_id, deadline, budget, |event| { 885 Some(event.as_json()) 886 }) 887 .await 888 } 889 890 const FIRST: &str = r#"{"id":"762bee187e9e645b81ec26ade05a69b5e8398caf527be8de0d9a45311ed0c7a0","pubkey":"585591529da0bab31b3b1b1f986611cf5f435dca84f978c89ee8a40cca7103df","created_at":1800000100,"kind":0,"tags":[],"content":"{\"display_name\":\"Moss Street Farm\",\"bot\":false,\"website\":\"https://mossstreet.example\",\"picture\":42}","sig":"4290da0bb6422986647bc8cd5f63bd52d49f41e7b665d3b47105b8109183e8d596f322c531d4061df53e1d2b70fda12d5d1c14f3720d7a56d9d0a03746af5109"}"#; 891 const SECOND: &str = r#"{"id":"56bfc78223bb2221bad82b539efdec1ade0f56d0eb0e1f592fd387df4b2ceee0","pubkey":"585591529da0bab31b3b1b1f986611cf5f435dca84f978c89ee8a40cca7103df","created_at":1700000001,"kind":0,"tags":[],"content":"{}","sig":"dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"}"#; 892 893 #[derive(Debug)] 894 struct MockSourceClient; 895 896 impl RelaySourceClient for MockSourceClient { 897 fn fetch<'a>(&'a self, query: SourceQuery) -> BoxFuture<'a, Vec<RelayFetchBatch>> { 898 Box::pin(async move { 899 query 900 .relays 901 .into_iter() 902 .map(|relay| RelayFetchBatch { 903 relay, 904 result: RelayFetchResult::Complete(vec![ 905 FIRST.to_owned(), 906 SECOND.to_owned(), 907 "{".to_owned(), 908 ]), 909 }) 910 .collect() 911 }) 912 } 913 } 914 915 fn transport() -> NostrTransport { 916 let config = Config::from_profile( 917 crate::profile::test_profile( 918 crate::RelayProfileKind::Public, 919 RelayUrlPolicy::Public, 920 ["wss://one.example", "wss://two.example"], 921 ) 922 .expect("profile"), 923 ); 924 NostrTransport::with_source_client(config, Arc::new(MockSourceClient)) 925 } 926 927 fn request(limit: u16) -> FetchRequest { 928 FetchRequest::new( 929 "nostr-fetch", 930 TargetSet::new(vec![ 931 Target::nostr_relay("wss://one.example").expect("one"), 932 Target::nostr_relay("wss://two.example").expect("two"), 933 ]) 934 .expect("targets"), 935 FetchBounds::new(limit, u64::MAX).expect("bounds"), 936 ) 937 .expect("request") 938 } 939 940 fn single_request(limit: u16) -> FetchRequest { 941 FetchRequest::new( 942 "nostr-fetch-one", 943 TargetSet::new(vec![Target::nostr_relay("wss://one.example").expect("one")]) 944 .expect("targets"), 945 FetchBounds::new(limit, u64::MAX).expect("bounds"), 946 ) 947 .expect("request") 948 } 949 950 #[test] 951 fn source_deduplicates_relays_reports_malformed_and_paginates() { 952 let transport = transport(); 953 let first_request = request(1); 954 let first = 955 futures::executor::block_on(transport.fetch(first_request)).expect("first page"); 956 assert_eq!(first.events().len(), 1); 957 assert!( 958 first 959 .target_outcomes() 960 .iter() 961 .all(|outcome| outcome.state() == FetchTargetState::Partial) 962 ); 963 let NextPage::Cursor(cursor) = first.next_page() else { 964 panic!("cursor expected"); 965 }; 966 967 let second_request = request(2).with_cursor(cursor.clone()); 968 let second = 969 futures::executor::block_on(transport.fetch(second_request)).expect("second page"); 970 assert_eq!(second.events().len(), 1); 971 assert!(matches!(second.next_page(), NextPage::Complete)); 972 assert_ne!( 973 first.events()[0].event().id(), 974 second.events()[0].event().id() 975 ); 976 } 977 978 #[test] 979 fn source_applies_kind_author_and_time_selectors_before_page_bounds() { 980 let event = radroots_event_codec::decode::signed_event(FIRST).expect("fixture event"); 981 let selector = FetchSelector::all() 982 .with_kinds(vec![0]) 983 .expect("kind") 984 .with_authors(vec![*event.pubkey()]) 985 .expect("author") 986 .with_since_unix_seconds(1_750_000_000) 987 .expect("since"); 988 let selected = 989 futures::executor::block_on(transport().fetch(request(10).with_selector(selector))) 990 .expect("selected page"); 991 assert_eq!(selected.events().len(), 1); 992 assert_eq!(selected.events()[0].event().id_str(), event.id_str()); 993 994 let excluded = FetchSelector::all() 995 .with_kinds(vec![1]) 996 .expect("excluded kind"); 997 let selected = 998 futures::executor::block_on(transport().fetch(request(10).with_selector(excluded))) 999 .expect("empty selected page"); 1000 assert!(selected.events().is_empty()); 1001 } 1002 1003 #[test] 1004 fn malformed_cursor_fails_before_relay_access() { 1005 let request = request(1).with_cursor(FetchCursor::parse("other:1:value").expect("opaque")); 1006 let error = futures::executor::block_on(transport().fetch(request)).expect_err("cursor"); 1007 assert_eq!(error, radroots_transport::Error::InvalidFetchCursor); 1008 } 1009 1010 #[test] 1011 fn dropping_an_unpolled_fetch_performs_no_relay_work() { 1012 #[derive(Debug)] 1013 struct CountingSourceClient(Arc<AtomicUsize>); 1014 1015 impl RelaySourceClient for CountingSourceClient { 1016 fn fetch<'a>(&'a self, _query: SourceQuery) -> BoxFuture<'a, Vec<RelayFetchBatch>> { 1017 self.0.fetch_add(1, AtomicOrdering::SeqCst); 1018 Box::pin(async { Vec::new() }) 1019 } 1020 } 1021 1022 let calls = Arc::new(AtomicUsize::new(0)); 1023 let config = Config::from_profile( 1024 crate::profile::test_profile( 1025 crate::RelayProfileKind::Public, 1026 RelayUrlPolicy::Public, 1027 ["wss://one.example"], 1028 ) 1029 .expect("profile"), 1030 ); 1031 let transport = NostrTransport::with_source_client( 1032 config, 1033 Arc::new(CountingSourceClient(Arc::clone(&calls))), 1034 ); 1035 let target_set = TargetSet::new(vec![ 1036 Target::nostr_relay("wss://one.example").expect("target"), 1037 ]) 1038 .expect("targets"); 1039 let fetch = transport.fetch( 1040 FetchRequest::new( 1041 "cancel-before-poll", 1042 target_set, 1043 FetchBounds::new(1, u64::MAX).expect("bounds"), 1044 ) 1045 .expect("request"), 1046 ); 1047 drop(fetch); 1048 assert_eq!(calls.load(AtomicOrdering::SeqCst), 0); 1049 } 1050 1051 #[test] 1052 fn adapter_and_generic_page_limits_are_identical() { 1053 assert_eq!(UPSTREAM_FETCH_LIMIT, 1_000); 1054 assert_eq!( 1055 UPSTREAM_FETCH_LIMIT, 1056 usize::from(radroots_transport::source::FETCH_PAGE_MAX_EVENTS) 1057 ); 1058 assert!(FetchBounds::new(1_001, u64::MAX).is_err()); 1059 } 1060 1061 #[derive(Debug)] 1062 struct ScriptedSourceClient(Vec<RelayFetchBatch>); 1063 1064 impl RelaySourceClient for ScriptedSourceClient { 1065 fn fetch<'a>(&'a self, _query: SourceQuery) -> BoxFuture<'a, Vec<RelayFetchBatch>> { 1066 Box::pin(async move { self.0.clone() }) 1067 } 1068 } 1069 1070 fn scripted(batches: Vec<RelayFetchBatch>) -> NostrTransport { 1071 let config = Config::from_profile( 1072 crate::profile::test_profile( 1073 crate::RelayProfileKind::Public, 1074 RelayUrlPolicy::Public, 1075 ["wss://one.example", "wss://two.example"], 1076 ) 1077 .expect("profile"), 1078 ); 1079 NostrTransport::with_source_client(config, Arc::new(ScriptedSourceClient(batches))) 1080 } 1081 1082 #[test] 1083 fn source_handles_failed_missing_duplicate_and_unexpected_batches() { 1084 let one = RelayUrl::parse("wss://one.example", RelayUrlPolicy::Public).expect("one"); 1085 let two = RelayUrl::parse("wss://two.example", RelayUrlPolicy::Public).expect("two"); 1086 let failed = futures::executor::block_on( 1087 scripted(vec![RelayFetchBatch { 1088 relay: one.clone(), 1089 result: RelayFetchResult::Failed("connection timeout".into()), 1090 }]) 1091 .fetch(request(10)), 1092 ) 1093 .expect("failed page"); 1094 assert_eq!(failed.target_outcomes().len(), 2); 1095 assert!(failed.events().is_empty()); 1096 1097 let duplicate = scripted(vec![ 1098 RelayFetchBatch { 1099 relay: one.clone(), 1100 result: RelayFetchResult::Complete(vec![]), 1101 }, 1102 RelayFetchBatch { 1103 relay: one, 1104 result: RelayFetchResult::Complete(vec![]), 1105 }, 1106 ]); 1107 assert_eq!( 1108 futures::executor::block_on(duplicate.fetch(request(10))), 1109 Err(radroots_transport::Error::DuplicateFetchTargetOutcome) 1110 ); 1111 1112 let other = RelayUrl::parse("wss://other.example", RelayUrlPolicy::Public).expect("other"); 1113 let unexpected = scripted(vec![RelayFetchBatch { 1114 relay: other, 1115 result: RelayFetchResult::Complete(vec![]), 1116 }]); 1117 assert_eq!( 1118 futures::executor::block_on(unexpected.fetch(request(10))), 1119 Err(radroots_transport::Error::UnexpectedFetchTargetOutcome) 1120 ); 1121 1122 let complete = futures::executor::block_on( 1123 scripted(vec![RelayFetchBatch { 1124 relay: two, 1125 result: RelayFetchResult::Complete(vec![]), 1126 }]) 1127 .fetch(request(10)), 1128 ) 1129 .expect("partial reporting"); 1130 assert_eq!(complete.target_outcomes().len(), 2); 1131 } 1132 1133 #[test] 1134 fn eose_timeout_and_resource_exhaustion_remain_distinct() { 1135 let relay = RelayUrl::parse("wss://one.example", RelayUrlPolicy::Public).expect("relay"); 1136 let fetch = |result| { 1137 futures::executor::block_on( 1138 scripted(vec![RelayFetchBatch { 1139 relay: relay.clone(), 1140 result, 1141 }]) 1142 .fetch(single_request(10)), 1143 ) 1144 .expect("page") 1145 }; 1146 1147 let complete = fetch(RelayFetchResult::Complete(vec![FIRST.to_owned()])); 1148 assert_eq!( 1149 complete.target_outcomes()[0].state(), 1150 FetchTargetState::Complete 1151 ); 1152 assert!(matches!(complete.next_page(), NextPage::Complete)); 1153 1154 let timeout = fetch(RelayFetchResult::Timeout(vec![FIRST.to_owned()])); 1155 assert_eq!(timeout.events().len(), 1); 1156 assert_eq!( 1157 timeout.target_outcomes()[0].state(), 1158 FetchTargetState::Cancelled 1159 ); 1160 1161 let exhausted = fetch(RelayFetchResult::ResourceLimit(vec![FIRST.to_owned()])); 1162 assert_eq!(exhausted.events().len(), 1); 1163 assert_eq!( 1164 exhausted.target_outcomes()[0].state(), 1165 FetchTargetState::Partial 1166 ); 1167 } 1168 1169 #[tokio::test] 1170 async fn live_completion_requires_eose_strictly_before_deadline() { 1171 let subscription_id = SubscriptionId::generate(); 1172 let (sender, mut receiver) = tokio::sync::broadcast::channel(2); 1173 sender 1174 .send(RelayNotification::Message { 1175 message: Box::new(RelayMessage::EndOfStoredEvents(Cow::Owned( 1176 subscription_id.clone(), 1177 ))), 1178 }) 1179 .expect("EOSE"); 1180 assert_eq!( 1181 collect_until_eose_test( 1182 &mut test_notifications(&mut receiver), 1183 &subscription_id, 1184 crate::host_time::Instant::now() + Duration::from_secs(1), 1185 &FetchBudget::default(), 1186 ) 1187 .await, 1188 RelayFetchResult::Complete(Vec::new()) 1189 ); 1190 1191 let (_sender, mut receiver) = tokio::sync::broadcast::channel(2); 1192 assert_eq!( 1193 collect_until_eose_test( 1194 &mut test_notifications(&mut receiver), 1195 &subscription_id, 1196 crate::host_time::Instant::now(), 1197 &FetchBudget::default() 1198 ) 1199 .await, 1200 RelayFetchResult::Timeout(Vec::new()) 1201 ); 1202 } 1203 1204 #[tokio::test] 1205 async fn exhausted_ingress_wins_over_queued_eose() { 1206 let subscription_id = SubscriptionId::generate(); 1207 let (sender, mut receiver) = tokio::sync::broadcast::channel(1); 1208 sender 1209 .send(RelayNotification::Message { 1210 message: Box::new(RelayMessage::EndOfStoredEvents(Cow::Owned( 1211 subscription_id.clone(), 1212 ))), 1213 }) 1214 .unwrap(); 1215 let budget = FetchBudget::default(); 1216 assert!(!budget.wire(budget::MAX_FETCH_BYTES + 1, 0, 0)); 1217 assert_eq!( 1218 collect_until_eose_test( 1219 &mut test_notifications(&mut receiver), 1220 &subscription_id, 1221 crate::host_time::Instant::now() + Duration::from_secs(1), 1222 &budget 1223 ) 1224 .await, 1225 RelayFetchResult::ResourceLimit(Vec::new()) 1226 ); 1227 } 1228 1229 #[tokio::test] 1230 async fn receiver_gap_cannot_turn_a_retained_eose_into_complete_evidence() { 1231 let id = SubscriptionId::generate(); 1232 let (sender, mut receiver) = tokio::sync::broadcast::channel(1); 1233 sender 1234 .send(RelayNotification::RelayStatus { 1235 status: nostr_sdk::prelude::RelayStatus::Connected, 1236 }) 1237 .unwrap(); 1238 sender 1239 .send(RelayNotification::Message { 1240 message: Box::new(RelayMessage::EndOfStoredEvents(Cow::Owned(id.clone()))), 1241 }) 1242 .unwrap(); 1243 assert_eq!( 1244 collect_until_eose_test( 1245 &mut test_notifications(&mut receiver), 1246 &id, 1247 crate::host_time::Instant::now() + Duration::from_secs(1), 1248 &FetchBudget::default(), 1249 ) 1250 .await, 1251 RelayFetchResult::Failed(String::from("relay notification gap")) 1252 ); 1253 } 1254 1255 #[tokio::test] 1256 async fn exhaustion_after_eose_before_finalization_retains_events_and_earlier_evidence() { 1257 let relays = ["wss://one.example", "wss://two.example"]; 1258 let registry = 1259 crate::source_ingress::IngressRegistry::new(relays.into_iter().map(str::to_owned)); 1260 let budget = Arc::new(FetchBudget::default()); 1261 let registration = registry 1262 .register(relays.into_iter().map(str::to_owned), Arc::clone(&budget)) 1263 .unwrap(); 1264 let connection = registry.connection(relays[1]).unwrap(); 1265 let mut batches = Vec::new(); 1266 for url in relays { 1267 let id = SubscriptionId::generate(); 1268 let (sender, mut receiver) = tokio::sync::broadcast::channel(2); 1269 sender 1270 .send(RelayNotification::Message { 1271 message: Box::new(RelayMessage::Event { 1272 subscription_id: Cow::Owned(id.clone()), 1273 event: Cow::Owned(nostr_sdk::prelude::Event::from_json(FIRST).unwrap()), 1274 }), 1275 }) 1276 .unwrap(); 1277 sender 1278 .send(RelayNotification::Message { 1279 message: Box::new(RelayMessage::EndOfStoredEvents(Cow::Owned(id.clone()))), 1280 }) 1281 .unwrap(); 1282 batches.push(RelayFetchBatch { 1283 relay: RelayUrl::parse(url, RelayUrlPolicy::Public).unwrap(), 1284 result: collect_until_eose_test( 1285 &mut test_notifications(&mut receiver), 1286 &id, 1287 crate::host_time::Instant::now() + Duration::from_secs(1), 1288 &budget, 1289 ) 1290 .await, 1291 }); 1292 } 1293 let before = batches.clone(); 1294 assert!(before.iter().all( 1295 |batch| matches!(&batch.result, RelayFetchResult::Complete(events) if events.len() == 1) 1296 )); 1297 assert!(!connection.charge(budget::MAX_FETCH_BYTES + 1, 0, 0)); 1298 assert!(!finish_fetch(&mut batches, registration)); 1299 assert_eq!(batches[0].result, before[0].result); 1300 let RelayFetchResult::Complete(expected) = &before[1].result else { 1301 panic!("completed collection"); 1302 }; 1303 assert_eq!( 1304 batches[1].result, 1305 RelayFetchResult::ResourceLimit(expected.clone()) 1306 ); 1307 } 1308 1309 #[test] 1310 fn finalization_preserves_success_partial_and_empty_results() { 1311 for (result, exhausted, expected_complete) in [ 1312 ( 1313 Some(RelayFetchResult::Complete(vec![FIRST.to_owned()])), 1314 false, 1315 true, 1316 ), 1317 ( 1318 Some(RelayFetchResult::Timeout(vec![FIRST.to_owned()])), 1319 false, 1320 false, 1321 ), 1322 (None, false, true), 1323 (None, true, false), 1324 ] { 1325 let registry = crate::source_ingress::IngressRegistry::new( 1326 ["wss://one.example".to_owned()].into_iter(), 1327 ); 1328 let budget = Arc::new(FetchBudget::default()); 1329 let registration = registry 1330 .register( 1331 ["wss://one.example".to_owned()].into_iter(), 1332 Arc::clone(&budget), 1333 ) 1334 .unwrap(); 1335 let connection = registry.connection("wss://one.example").unwrap(); 1336 let mut batches = result 1337 .map(|result| RelayFetchBatch { 1338 relay: RelayUrl::parse("wss://one.example", RelayUrlPolicy::Public).unwrap(), 1339 result, 1340 }) 1341 .into_iter() 1342 .collect::<Vec<_>>(); 1343 let before = batches 1344 .iter() 1345 .map(|batch| batch.result.clone()) 1346 .collect::<Vec<_>>(); 1347 if exhausted { 1348 assert!(!connection.charge(budget::MAX_FETCH_BYTES + 1, 0, 0)); 1349 } 1350 assert_eq!(finish_fetch(&mut batches, registration), expected_complete); 1351 assert_eq!( 1352 batches 1353 .iter() 1354 .map(|batch| batch.result.clone()) 1355 .collect::<Vec<_>>(), 1356 before 1357 ); 1358 assert_eq!( 1359 connection.admitted(&std::task::Context::from_waker( 1360 futures::task::noop_waker_ref() 1361 )), 1362 expected_complete 1363 ); 1364 } 1365 } 1366 1367 #[tokio::test] 1368 async fn completed_connection_ownership_is_retained_until_the_whole_query_finishes() { 1369 let client = nostr_sdk::client::Client::default(); 1370 client.add_relay("wss://one.example").await.unwrap(); 1371 let relay = client.relay("wss://one.example").await.unwrap().unwrap(); 1372 let connections = FetchConnections::default(); 1373 connections.retain(relay.clone()).unwrap(); 1374 assert_eq!(connections.0.lock().unwrap().len(), 1); 1375 connections.finish(); 1376 assert!(connections.0.lock().unwrap().is_empty()); 1377 connections.retain(relay).unwrap(); 1378 drop(connections); 1379 } 1380 1381 #[tokio::test] 1382 async fn complete_connection_inventory_is_inert_and_preserves_shared_sockets_on_success() { 1383 let client = nostr_sdk::client::Client::default(); 1384 let relays = ["wss://one.example", "wss://two.example"] 1385 .map(|url| RelayUrl::parse(url, RelayUrlPolicy::Public).unwrap()); 1386 let connections = admit_fetch_connections( 1387 &client, 1388 &relays, 1389 crate::host_time::Instant::now() + Duration::from_secs(1), 1390 ) 1391 .await 1392 .unwrap(); 1393 assert_eq!(connections.0.lock().unwrap().len(), 2); 1394 for relay in &relays { 1395 assert_eq!( 1396 client 1397 .relay(relay.as_str()) 1398 .await 1399 .unwrap() 1400 .unwrap() 1401 .status(), 1402 nostr_sdk::prelude::RelayStatus::Initialized 1403 ); 1404 } 1405 connections.finish(); 1406 drop(connections); 1407 for relay in &relays { 1408 assert_eq!( 1409 client 1410 .relay(relay.as_str()) 1411 .await 1412 .unwrap() 1413 .unwrap() 1414 .status(), 1415 nostr_sdk::prelude::RelayStatus::Initialized 1416 ); 1417 } 1418 } 1419 1420 #[tokio::test] 1421 async fn expired_inventory_performs_no_sdk_admission() { 1422 let client = nostr_sdk::client::Client::default(); 1423 let relay = RelayUrl::parse("wss://one.example", RelayUrlPolicy::Public).unwrap(); 1424 for relays in [vec![relay], Vec::new()] { 1425 assert!(matches!( 1426 admit_fetch_connections(&client, &relays, crate::host_time::Instant::now()).await, 1427 Err(RelayFetchResult::Timeout(_)) 1428 )); 1429 assert!(client.relays().await.is_empty()); 1430 } 1431 } 1432 1433 #[tokio::test] 1434 async fn failed_inventory_releases_every_handle_already_admitted() { 1435 let client = nostr_sdk::client::Client::builder() 1436 .max_relays(std::num::NonZeroUsize::new(1)) 1437 .build(); 1438 let relays = ["wss://one.example", "wss://two.example"] 1439 .map(|url| RelayUrl::parse(url, RelayUrlPolicy::Public).unwrap()); 1440 assert!(matches!( 1441 admit_fetch_connections( 1442 &client, 1443 &relays, 1444 crate::host_time::Instant::now() + Duration::from_secs(1) 1445 ) 1446 .await, 1447 Err(RelayFetchResult::Failed(_)) 1448 )); 1449 assert_eq!(client.relays().await.len(), 1); 1450 assert_eq!( 1451 client 1452 .relay(relays[0].as_str()) 1453 .await 1454 .unwrap() 1455 .unwrap() 1456 .status(), 1457 nostr_sdk::prelude::RelayStatus::Idle 1458 ); 1459 } 1460 1461 #[derive(Clone, Copy)] 1462 enum QueuedCleanup { 1463 Cancel, 1464 Deadline, 1465 Resource, 1466 } 1467 1468 async fn queued_connection_cleanup(mode: QueuedCleanup) { 1469 use futures::SinkExt; 1470 use tokio_tungstenite::{accept_async, tungstenite::Message}; 1471 let first = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); 1472 let second = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); 1473 let urls = [ 1474 format!("ws://{}", first.local_addr().unwrap()), 1475 format!("ws://{}", second.local_addr().unwrap()), 1476 ]; 1477 let endpoints = urls 1478 .iter() 1479 .map(|url| { 1480 crate::RelayEndpoint::new(url, RelayUrlPolicy::Local, crate::RelayAccess::ReadOnly) 1481 .unwrap() 1482 }) 1483 .collect::<Vec<_>>(); 1484 let connector = crate::session_socket::SessionWebsocketTransport::new( 1485 &endpoints, 1486 Duration::from_secs(1), 1487 std::sync::Arc::new(crate::test_host::LoopbackConnector), 1488 ); 1489 let ingress = connector.ingress.clone(); 1490 let client = nostr_sdk::client::Client::builder() 1491 .websocket_transport(connector) 1492 .build(); 1493 let (started, observed) = tokio::sync::oneshot::channel(); 1494 let first_server = tokio::spawn(async move { 1495 let (tcp, _) = first.accept().await.unwrap(); 1496 let mut socket = accept_async(tcp).await.unwrap(); 1497 let mut started = Some(started); 1498 while let Some(message) = socket.next().await { 1499 match message { 1500 Ok(Message::Text(text)) => { 1501 let value: serde_json::Value = serde_json::from_str(&text).unwrap(); 1502 if value[0] == "REQ" { 1503 if let Some(started) = started.take() { 1504 let _ = started.send(()); 1505 } 1506 if matches!(mode, QueuedCleanup::Resource) { 1507 let malformed = serde_json::to_string(&( 1508 "EVENT", 1509 &value[1], 1510 // Keep primitive wire identities admissible so missing 1511 // event fields reach the aggregate raw-ingress budget. 1512 serde_json::json!({ 1513 "id": "00".repeat(32), 1514 "pubkey": "11".repeat(32), 1515 "sig": "22".repeat(64), 1516 "invalid": "x".repeat(384 * 1024), 1517 }), 1518 )) 1519 .unwrap(); 1520 for _ in 0..24 { 1521 if socket 1522 .send(Message::Text(malformed.clone().into())) 1523 .await 1524 .is_err() 1525 { 1526 return; 1527 } 1528 } 1529 } 1530 } 1531 } 1532 Ok(Message::Close(_)) | Err(_) => return, 1533 _ => { 1534 if socket.flush().await.is_err() { 1535 return; 1536 } 1537 } 1538 } 1539 } 1540 }); 1541 let queued_requests = Arc::new(AtomicUsize::new(0)); 1542 let requests = Arc::clone(&queued_requests); 1543 let (closed, closure) = tokio::sync::oneshot::channel(); 1544 let second_server = tokio::spawn(async move { 1545 let (tcp, _) = second.accept().await.unwrap(); 1546 let mut socket = accept_async(tcp).await.unwrap(); 1547 while let Some(message) = socket.next().await { 1548 match message { 1549 Ok(Message::Text(text)) => { 1550 let value: serde_json::Value = serde_json::from_str(&text).unwrap(); 1551 if value[0] == "REQ" { 1552 requests.fetch_add(1, AtomicOrdering::SeqCst); 1553 } 1554 } 1555 Ok(Message::Close(_)) | Err(_) => break, 1556 _ => { 1557 if socket.flush().await.is_err() { 1558 break; 1559 } 1560 } 1561 } 1562 } 1563 let _ = closed.send(()); 1564 }); 1565 client.add_relay(urls[1].as_str()).await.unwrap(); 1566 crate::client::connect_relay(&client, urls[1].as_str(), Duration::from_secs(1)) 1567 .await 1568 .unwrap(); 1569 let queued = client.relay(urls[1].as_str()).await.unwrap().unwrap(); 1570 let source = LiveRelaySourceClient::new( 1571 client, 1572 ingress, 1573 Arc::new(crate::connections::Connections::new(2)), 1574 ); 1575 let query = SourceQuery { 1576 relays: urls 1577 .iter() 1578 .map(|url| RelayUrl::parse(url, RelayUrlPolicy::Local).unwrap()) 1579 .collect(), 1580 selector: radroots_transport::source::FetchSelector::all(), 1581 until_unix_seconds: None, 1582 connect_timeout: Duration::from_secs(1), 1583 deadline: crate::host_time::Instant::now() 1584 + if matches!(mode, QueuedCleanup::Deadline) { 1585 Duration::from_millis(500) 1586 } else { 1587 Duration::from_secs(5) 1588 }, 1589 max_connections: 1, 1590 }; 1591 let mut fetch = source.fetch(query); 1592 let started = crate::host_time::timeout(Duration::from_secs(10), async { 1593 tokio::select! { 1594 biased; 1595 result = observed => result.is_ok(), 1596 _ = &mut fetch => false, 1597 } 1598 }) 1599 .await; 1600 let batches = if matches!(mode, QueuedCleanup::Cancel) { 1601 None 1602 } else { 1603 Some(crate::host_time::timeout(Duration::from_secs(10), &mut fetch).await) 1604 }; 1605 drop(fetch); 1606 let status = queued.status(); 1607 let closed = crate::host_time::timeout(Duration::from_secs(2), closure).await; 1608 for server in [first_server, second_server] { 1609 server.abort(); 1610 let result = server.await; 1611 assert!(result.is_ok() || result.unwrap_err().is_cancelled()); 1612 } 1613 assert!( 1614 started.unwrap(), 1615 "first relay must own the only scheduled batch" 1616 ); 1617 assert_eq!(queued_requests.load(AtomicOrdering::SeqCst), 0); 1618 assert_eq!( 1619 status, 1620 nostr_sdk::prelude::RelayStatus::Idle, 1621 "queued preexisting socket must lose automatic reconnect authority" 1622 ); 1623 closed.unwrap().unwrap(); 1624 if let Some(batches) = batches { 1625 let batches = batches.unwrap(); 1626 assert_eq!(batches.len(), 2); 1627 assert!(batches.iter().all(|batch| match mode { 1628 QueuedCleanup::Deadline => matches!(batch.result, RelayFetchResult::Timeout(_)), 1629 QueuedCleanup::Resource => 1630 matches!(batch.result, RelayFetchResult::ResourceLimit(_)), 1631 QueuedCleanup::Cancel => false, 1632 })); 1633 } 1634 } 1635 1636 #[tokio::test(flavor = "multi_thread")] 1637 async fn cancellation_terminates_preexisting_queued_relay_reconnect_authority() { 1638 queued_connection_cleanup(QueuedCleanup::Cancel).await; 1639 } 1640 1641 #[tokio::test(flavor = "multi_thread")] 1642 async fn deadline_terminates_preexisting_queued_relay_reconnect_authority() { 1643 queued_connection_cleanup(QueuedCleanup::Deadline).await; 1644 } 1645 1646 #[tokio::test(flavor = "multi_thread")] 1647 async fn exhaustion_terminates_preexisting_queued_relay_reconnect_authority() { 1648 queued_connection_cleanup(QueuedCleanup::Resource).await; 1649 } 1650 1651 #[test] 1652 fn source_rejects_unconfigured_targets_and_expired_deadlines() { 1653 let unconfigured_targets = TargetSet::new(vec![ 1654 Target::nostr_relay("wss://other.example").expect("other"), 1655 ]) 1656 .expect("targets"); 1657 let unconfigured = FetchRequest::new( 1658 "unconfigured", 1659 unconfigured_targets, 1660 FetchBounds::new(1, u64::MAX).expect("bounds"), 1661 ) 1662 .expect("request"); 1663 let page = futures::executor::block_on(transport().fetch(unconfigured)).expect("page"); 1664 assert_eq!( 1665 page.target_outcomes()[0].state(), 1666 FetchTargetState::FailedTerminal 1667 ); 1668 1669 let expired = FetchRequest::new( 1670 "expired", 1671 single_request(1).target_set().clone(), 1672 FetchBounds::new(1, 1).expect("bounds"), 1673 ) 1674 .expect("request"); 1675 let page = futures::executor::block_on(transport().fetch(expired)).expect("page"); 1676 assert!(page.events().is_empty()); 1677 assert_eq!(page.target_outcomes().len(), 1); 1678 assert_eq!( 1679 page.target_outcomes()[0].state(), 1680 FetchTargetState::Cancelled 1681 ); 1682 assert!(futures::executor::block_on(transport().status()).is_ok()); 1683 } 1684 1685 #[test] 1686 fn cursor_and_candidate_ordering_cover_boundaries() { 1687 for invalid in [ 1688 "nostr-v1", 1689 "nostr-v2:not-a-time:id:scope", 1690 "nostr-v2:1", 1691 "nostr-v2:1:id:scope:extra", 1692 "nostr-v2:1:abc:scope", 1693 "nostr-v2:1:gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg:scope", 1694 ] { 1695 let cursor = FetchCursor::parse(invalid).expect("opaque cursor"); 1696 assert!(matches!( 1697 parse_cursor(&cursor, &"a".repeat(64)), 1698 Err(radroots_transport::Error::InvalidFetchCursor) 1699 )); 1700 } 1701 let cursor = RelayCursor::new(10, "b".repeat(64)).expect("cursor"); 1702 let relay = RelayUrl::parse("wss://one.example", RelayUrlPolicy::Public).expect("relay"); 1703 let older = Candidate { 1704 relay: relay.clone(), 1705 raw: String::new(), 1706 created_at: 9, 1707 event_id: "f".repeat(64), 1708 }; 1709 let earlier_id = Candidate { 1710 relay: relay.clone(), 1711 raw: String::new(), 1712 created_at: 10, 1713 event_id: "a".repeat(64), 1714 }; 1715 let later = Candidate { 1716 relay, 1717 raw: String::new(), 1718 created_at: 11, 1719 event_id: "0".repeat(64), 1720 }; 1721 assert!(candidate_is_after_cursor(&older, &cursor)); 1722 assert!(candidate_is_after_cursor(&earlier_id, &cursor)); 1723 assert!(!candidate_is_after_cursor(&later, &cursor)); 1724 assert_ne!(compare_candidate(&older, &later), Ordering::Equal); 1725 } 1726 1727 #[test] 1728 fn continuation_cursor_is_bound_to_exact_targets_and_selector() { 1729 let first = futures::executor::block_on(transport().fetch(request(1))).expect("first page"); 1730 let NextPage::Cursor(cursor) = first.next_page() else { 1731 panic!("cursor expected"); 1732 }; 1733 let different_selector = FetchSelector::all().with_kinds(vec![1]).expect("selector"); 1734 let error = futures::executor::block_on( 1735 transport().fetch( 1736 request(1) 1737 .with_selector(different_selector) 1738 .with_cursor(cursor.clone()), 1739 ), 1740 ) 1741 .expect_err("scope mismatch"); 1742 assert_eq!(error, radroots_transport::Error::InvalidFetchCursor); 1743 1744 let tagged_selector = FetchSelector::all() 1745 .with_exact_tag_value('d', "trade-1") 1746 .expect("tag selector"); 1747 let error = futures::executor::block_on( 1748 transport().fetch( 1749 request(1) 1750 .with_selector(tagged_selector) 1751 .with_cursor(cursor.clone()), 1752 ), 1753 ) 1754 .expect_err("tag scope mismatch"); 1755 assert_eq!(error, radroots_transport::Error::InvalidFetchCursor); 1756 1757 let other_targets = 1758 TargetSet::new(vec![Target::nostr_relay("wss://one.example").expect("one")]) 1759 .expect("targets"); 1760 let error = futures::executor::block_on( 1761 transport().fetch( 1762 FetchRequest::new( 1763 "different-targets", 1764 other_targets, 1765 FetchBounds::new(1, u64::MAX).expect("bounds"), 1766 ) 1767 .expect("request") 1768 .with_cursor(cursor.clone()), 1769 ), 1770 ) 1771 .expect_err("target scope mismatch"); 1772 assert_eq!(error, radroots_transport::Error::InvalidFetchCursor); 1773 } 1774 1775 #[test] 1776 fn exact_tag_selector_maps_to_nostr_filter_and_is_defensively_enforced() { 1777 let selector = FetchSelector::all() 1778 .with_exact_tag_value('d', "trade-2") 1779 .and_then(|selector| selector.with_exact_tag_value('d', "trade-1")) 1780 .expect("tag selector"); 1781 let encoded = apply_exact_tag_filters(Filter::new(), &selector) 1782 .expect("Nostr filter") 1783 .as_json(); 1784 assert!(encoded.contains("\"#d\":[\"trade-1\",\"trade-2\"]")); 1785 1786 let selected = 1787 futures::executor::block_on(transport().fetch(request(10).with_selector(selector))) 1788 .expect("selected page"); 1789 assert!(selected.events().is_empty()); 1790 } 1791 1792 #[test] 1793 fn live_source_short_circuits_selectors_that_cannot_be_encoded() { 1794 let client = LiveRelaySourceClient::isolated(); 1795 let relay = RelayUrl::parse("wss://one.example", RelayUrlPolicy::Public).expect("relay"); 1796 let selector = FetchSelector::all() 1797 .with_kinds(vec![u32::MAX]) 1798 .expect("kind"); 1799 let batches = futures::executor::block_on(client.fetch(SourceQuery { 1800 relays: vec![relay], 1801 selector, 1802 until_unix_seconds: None, 1803 connect_timeout: Duration::from_millis(1), 1804 deadline: crate::host_time::Instant::now() + Duration::from_millis(1), 1805 max_connections: 1, 1806 })); 1807 assert_eq!(batches.len(), 1); 1808 assert_eq!(batches[0].result, RelayFetchResult::Complete(vec![])); 1809 } 1810 1811 #[tokio::test] 1812 async fn continuous_notifications_terminate_at_the_shared_work_limit() { 1813 let id = SubscriptionId::generate(); 1814 let (sender, mut receiver) = 1815 tokio::sync::broadcast::channel(budget::MAX_FETCH_NOTIFICATIONS + 1); 1816 for _ in 0..=budget::MAX_FETCH_NOTIFICATIONS { 1817 sender 1818 .send(RelayNotification::RelayStatus { 1819 status: nostr_sdk::prelude::RelayStatus::Connected, 1820 }) 1821 .unwrap(); 1822 } 1823 assert_eq!( 1824 collect_until_eose_test( 1825 &mut test_notifications(&mut receiver), 1826 &id, 1827 crate::host_time::Instant::now() + Duration::from_secs(10), 1828 &FetchBudget::default() 1829 ) 1830 .await, 1831 RelayFetchResult::ResourceLimit(Vec::new()) 1832 ); 1833 } 1834 1835 #[tokio::test] 1836 async fn repeated_events_consume_inventory_before_deduplication() { 1837 let id = SubscriptionId::generate(); 1838 let event = nostr_sdk::prelude::Event::from_json(FIRST).unwrap(); 1839 let (sender, mut receiver) = tokio::sync::broadcast::channel(UPSTREAM_FETCH_LIMIT + 1); 1840 for _ in 0..=UPSTREAM_FETCH_LIMIT { 1841 sender 1842 .send(RelayNotification::Message { 1843 message: Box::new(RelayMessage::Event { 1844 subscription_id: Cow::Owned(id.clone()), 1845 event: Cow::Owned(event.clone()), 1846 }), 1847 }) 1848 .unwrap(); 1849 } 1850 let result = collect_until_eose_test( 1851 &mut test_notifications(&mut receiver), 1852 &id, 1853 crate::host_time::Instant::now() + Duration::from_secs(10), 1854 &FetchBudget::default(), 1855 ) 1856 .await; 1857 let RelayFetchResult::ResourceLimit(events) = result else { 1858 panic!("bounded inventory"); 1859 }; 1860 assert_eq!(events.len(), UPSTREAM_FETCH_LIMIT); 1861 } 1862 1863 #[test] 1864 fn defensive_parse_budget_preserves_earlier_events_and_refuses_excess_work() { 1865 let relay = RelayUrl::parse("wss://one.example", RelayUrlPolicy::Public).unwrap(); 1866 let mut records = vec![FIRST.to_owned()]; 1867 records.extend((1..UPSTREAM_FETCH_LIMIT).map(|_| "{".to_owned())); 1868 records.push(SECOND.to_owned()); 1869 for records in [ 1870 records, 1871 vec![ 1872 FIRST.to_owned(), 1873 "x".repeat(budget::MAX_EVENT_BYTES + 1), 1874 SECOND.to_owned(), 1875 ], 1876 ] { 1877 let page = futures::executor::block_on( 1878 scripted(vec![RelayFetchBatch { 1879 relay: relay.clone(), 1880 result: RelayFetchResult::Complete(records), 1881 }]) 1882 .fetch(single_request(10)), 1883 ) 1884 .unwrap(); 1885 assert_eq!(page.events().len(), 1); 1886 assert_eq!( 1887 page.events()[0].event().id_str(), 1888 radroots_event_codec::decode::signed_event(FIRST) 1889 .unwrap() 1890 .id_str() 1891 ); 1892 assert_eq!(page.target_outcomes()[0].state(), FetchTargetState::Partial); 1893 } 1894 } 1895 1896 #[tokio::test] 1897 async fn completed_relay_batches_do_not_refund_the_shared_byte_budget() { 1898 let mut wire: serde_json::Value = serde_json::from_str(FIRST).unwrap(); 1899 wire["content"] = serde_json::json!(""); 1900 let empty = nostr_sdk::prelude::Event::from_json(wire.to_string()).unwrap(); 1901 wire["content"] = 1902 serde_json::json!("x".repeat(budget::MAX_EVENT_BYTES - empty.as_json().len())); 1903 // Collection bounds precede canonical event admission; the fixture only 1904 // needs the upstream event structure and an exact serialized size. 1905 let event = nostr_sdk::prelude::Event::from_json(wire.to_string()).unwrap(); 1906 assert_eq!(event.as_json().len(), budget::MAX_EVENT_BYTES); 1907 let shared = FetchBudget::default(); 1908 let mut retained_bytes = 0; 1909 for batch in 0..2 { 1910 let id = SubscriptionId::generate(); 1911 let (sender, mut receiver) = tokio::sync::broadcast::channel(18); 1912 for _ in 0..17 { 1913 sender 1914 .send(RelayNotification::Message { 1915 message: Box::new(RelayMessage::Event { 1916 subscription_id: Cow::Owned(id.clone()), 1917 event: Cow::Owned(event.clone()), 1918 }), 1919 }) 1920 .unwrap(); 1921 } 1922 sender 1923 .send(RelayNotification::Message { 1924 message: Box::new(RelayMessage::EndOfStoredEvents(Cow::Owned(id.clone()))), 1925 }) 1926 .unwrap(); 1927 let result = collect_until_eose_test( 1928 &mut test_notifications(&mut receiver), 1929 &id, 1930 crate::host_time::Instant::now() + Duration::from_secs(10), 1931 &shared, 1932 ) 1933 .await; 1934 let events = match (batch, result) { 1935 (0, RelayFetchResult::Complete(events)) => { 1936 assert_eq!(events.len(), 17); 1937 events 1938 } 1939 (1, RelayFetchResult::ResourceLimit(events)) => { 1940 assert_eq!(events.len(), 15); 1941 events 1942 } 1943 _ => panic!("the second relay must exhaust the shared byte budget"), 1944 }; 1945 retained_bytes += events.iter().map(String::len).sum::<usize>(); 1946 } 1947 assert_eq!(retained_bytes, budget::MAX_FETCH_BYTES); 1948 assert!(!shared.event(1)); 1949 } 1950 1951 #[test] 1952 fn duplicate_inventory_is_bounded_across_all_relay_batches_before_deduplication() { 1953 let urls = (0..5) 1954 .map(|index| format!("wss://relay{index}.example")) 1955 .collect::<Vec<_>>(); 1956 let config = Config::from_profile( 1957 crate::profile::test_profile( 1958 crate::RelayProfileKind::Public, 1959 RelayUrlPolicy::Public, 1960 urls.iter().map(String::as_str), 1961 ) 1962 .unwrap(), 1963 ); 1964 let targets = TargetSet::new( 1965 config 1966 .read_relays() 1967 .map(|relay| relay.to_target().unwrap()) 1968 .collect(), 1969 ) 1970 .unwrap(); 1971 let request = FetchRequest::new( 1972 "aggregate-duplicates", 1973 targets, 1974 FetchBounds::new(10, unix_time_ms() + 10_000).unwrap(), 1975 ) 1976 .unwrap(); 1977 let batches = urls 1978 .iter() 1979 .map(|url| RelayFetchBatch { 1980 relay: RelayUrl::parse(url, RelayUrlPolicy::Public).unwrap(), 1981 result: RelayFetchResult::Complete(vec![FIRST.to_owned(); UPSTREAM_FETCH_LIMIT]), 1982 }) 1983 .collect(); 1984 let transport = 1985 NostrTransport::with_source_client(config, Arc::new(ScriptedSourceClient(batches))); 1986 let page = futures::executor::block_on(transport.fetch(request)).unwrap(); 1987 assert_eq!(page.events().len(), 1); 1988 assert_eq!(page.target_outcomes().len(), 5); 1989 assert_eq!( 1990 page.target_outcomes() 1991 .iter() 1992 .filter(|outcome| outcome.state() == FetchTargetState::Complete) 1993 .count(), 1994 0 1995 ); 1996 assert_eq!( 1997 page.target_outcomes() 1998 .iter() 1999 .filter(|outcome| outcome.state() == FetchTargetState::Partial) 2000 .count(), 2001 5 2002 ); 2003 let report = transport.relay_status(); 2004 assert_eq!( 2005 report 2006 .relays() 2007 .iter() 2008 .filter(|relay| relay.read().state() == crate::RelayEvidenceState::Available) 2009 .count(), 2010 4 2011 ); 2012 assert_eq!( 2013 report 2014 .relays() 2015 .iter() 2016 .filter(|relay| relay.read().state() == crate::RelayEvidenceState::Unavailable) 2017 .count(), 2018 1 2019 ); 2020 } 2021 2022 fn test_notifications( 2023 receiver: &mut tokio::sync::broadcast::Receiver<RelayNotification>, 2024 ) -> std::pin::Pin<Box<dyn Stream<Item = Result<RelayNotification, ()>> + Send + '_>> { 2025 Box::pin(futures::stream::unfold(receiver, |receiver| async { 2026 match receiver.recv().await { 2027 Ok(value) => Some((Ok(value), receiver)), 2028 Err(tokio::sync::broadcast::error::RecvError::Lagged(_)) => { 2029 Some((Err(()), receiver)) 2030 } 2031 Err(tokio::sync::broadcast::error::RecvError::Closed) => None, 2032 } 2033 })) 2034 } 2035 }