lib

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

fetch_bounds.rs (12620B)


      1 use futures::{SinkExt, StreamExt};
      2 use nostr_sdk::prelude::{EventBuilder, FinalizeEvent, Keys, Kind};
      3 use radroots_transport::{
      4     EventSource, FetchRequest, TargetSet, outcome::FetchTargetState, source::FetchBounds,
      5 };
      6 use radroots_transport_nostr::{
      7     Config, NostrTransport, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind,
      8     RelayUrlPolicy,
      9 };
     10 use serde_json::Value;
     11 use std::{
     12     sync::{
     13         Arc,
     14         atomic::{AtomicUsize, Ordering},
     15     },
     16     time::{Duration, SystemTime, UNIX_EPOCH},
     17 };
     18 use tokio::{net::TcpListener, sync::oneshot};
     19 use tokio_tungstenite::{accept_async, tungstenite::Message};
     20 
     21 fn transport(urls: &[String], connections: usize) -> (NostrTransport, FetchRequest) {
     22     let endpoints = urls
     23         .iter()
     24         .map(|url| RelayEndpoint::new(url, RelayUrlPolicy::Local, RelayAccess::ReadOnly).unwrap());
     25     let profile = RelayProfile::explicit(RelayProfileKind::Simulator, endpoints).unwrap();
     26     let config = Config::from_profile(profile)
     27         .with_timeouts(1000, 1000, 500)
     28         .unwrap()
     29         .with_max_connections(connections)
     30         .unwrap();
     31     let targets = TargetSet::new(
     32         config
     33             .read_relays()
     34             .map(|relay| relay.to_target().unwrap())
     35             .collect(),
     36     )
     37     .unwrap();
     38     let now = SystemTime::now()
     39         .duration_since(UNIX_EPOCH)
     40         .unwrap()
     41         .as_millis() as u64;
     42     let request = FetchRequest::new(
     43         "bounded-loopback",
     44         targets,
     45         FetchBounds::new(10, now + 5000).unwrap(),
     46     )
     47     .unwrap();
     48     (
     49         radroots_transport_nostr_native::create_transport(config),
     50         request,
     51     )
     52 }
     53 
     54 async fn listener() -> (TcpListener, String) {
     55     let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
     56     let url = format!("ws://{}", listener.local_addr().unwrap());
     57     (listener, url)
     58 }
     59 
     60 fn event(content: &str) -> Value {
     61     let keys =
     62         Keys::parse("0000000000000000000000000000000000000000000000000000000000000001").unwrap();
     63     let event = EventBuilder::new(Kind::TextNote, content)
     64         .finalize(&keys)
     65         .unwrap();
     66     serde_json::from_str(&event.as_json()).unwrap()
     67 }
     68 
     69 async fn serve(
     70     listener: TcpListener,
     71     payload: Option<Value>,
     72     eose: bool,
     73     requests: Arc<AtomicUsize>,
     74 ) {
     75     let (stream, _) = listener.accept().await.unwrap();
     76     let mut socket = accept_async(stream).await.unwrap();
     77     while let Some(message) = socket.next().await {
     78         let Ok(Message::Text(message)) = message else {
     79             continue;
     80         };
     81         let values: Value = serde_json::from_str(&message).unwrap();
     82         if values[0] != "REQ" {
     83             continue;
     84         }
     85         requests.fetch_add(1, Ordering::SeqCst);
     86         if let Some(payload) = &payload {
     87             socket
     88                 .send(Message::Text(
     89                     serde_json::to_string(&("EVENT", &values[1], payload))
     90                         .unwrap()
     91                         .into(),
     92                 ))
     93                 .await
     94                 .unwrap();
     95         }
     96         if eose {
     97             socket
     98                 .send(Message::Text(
     99                     serde_json::to_string(&("EOSE", &values[1])).unwrap().into(),
    100                 ))
    101                 .await
    102                 .unwrap();
    103         }
    104         std::future::pending::<()>().await;
    105     }
    106 }
    107 
    108 #[tokio::test(flavor = "multi_thread")]
    109 async fn a_cached_event_id_never_admits_a_changed_signature() {
    110     let (listener, url) = listener().await;
    111     let valid = event("cached signature admission");
    112     let mut changed = valid.clone();
    113     changed["sig"] = Value::String("0".repeat(128));
    114     let (release, released) = oneshot::channel();
    115     let server = tokio::spawn(async move {
    116         let (stream, _) = listener.accept().await.unwrap();
    117         let mut socket = accept_async(stream).await.unwrap();
    118         for payload in [valid, changed, event("valid continuation after rejection")] {
    119             loop {
    120                 let message = socket.next().await.unwrap().unwrap();
    121                 let Message::Text(text) = message else {
    122                     socket.flush().await.unwrap();
    123                     continue;
    124                 };
    125                 let values: Value = serde_json::from_str(&text).unwrap();
    126                 if values[0] != "REQ" {
    127                     continue;
    128                 }
    129                 socket
    130                     .send(Message::Text(
    131                         serde_json::to_string(&("EVENT", &values[1], &payload))
    132                             .unwrap()
    133                             .into(),
    134                     ))
    135                     .await
    136                     .unwrap();
    137                 socket
    138                     .send(Message::Text(
    139                         serde_json::to_string(&("EOSE", &values[1])).unwrap().into(),
    140                     ))
    141                     .await
    142                     .unwrap();
    143                 break;
    144             }
    145         }
    146         released.await.unwrap();
    147     });
    148     let (transport, request) = transport(&[url], 1);
    149     let pages = tokio::time::timeout(Duration::from_secs(5), async {
    150         let first = transport.fetch(request.clone()).await.unwrap();
    151         let repeated = transport.fetch(request.clone()).await.unwrap();
    152         let continuation = transport.fetch(request).await.unwrap();
    153         (first, repeated, continuation)
    154     })
    155     .await
    156     .unwrap();
    157     release.send(()).unwrap();
    158     server.await.unwrap();
    159     assert_eq!(pages.0.events().len(), 1);
    160     assert!(
    161         pages.1.events().is_empty(),
    162         "changed signature reached fetch output"
    163     );
    164     assert_eq!(pages.2.events().len(), 1);
    165     assert!(
    166         [&pages.0, &pages.1, &pages.2]
    167             .into_iter()
    168             .all(|page| page.target_outcomes()[0].state() == FetchTargetState::Complete)
    169     );
    170 }
    171 
    172 #[tokio::test(flavor = "multi_thread")]
    173 async fn overlong_event_identifiers_never_become_normalized_fetch_results() {
    174     for field in ["id", "pubkey", "sig"] {
    175         let (listener, url) = listener().await;
    176         let mut payload = event("strict wire identifiers");
    177         payload[field] = Value::String(format!("{}00", payload[field].as_str().unwrap()));
    178         let calls = Arc::new(AtomicUsize::new(0));
    179         let server = tokio::spawn(serve(listener, Some(payload), true, Arc::clone(&calls)));
    180         let (transport, request) = transport(&[url], 1);
    181         let page = tokio::time::timeout(Duration::from_secs(5), transport.fetch(request))
    182             .await
    183             .unwrap()
    184             .unwrap();
    185         server.abort();
    186         assert_eq!(calls.load(Ordering::SeqCst), 1);
    187         assert!(page.events().is_empty(), "{field}");
    188         assert_ne!(
    189             page.target_outcomes()[0].state(),
    190             FetchTargetState::Complete,
    191             "{field}"
    192         );
    193     }
    194 }
    195 
    196 #[tokio::test(flavor = "multi_thread")]
    197 async fn queued_relays_do_not_receive_a_fresh_timeout_after_a_stalled_relay() {
    198     let (first, first_url) = listener().await;
    199     let (second, second_url) = listener().await;
    200     // Adapter scheduling is canonical URL order, independent of profile order.
    201     let mut relays = [(first_url, first), (second_url, second)];
    202     relays.sort_by(|left, right| left.0.cmp(&right.0));
    203     let [(first_url, first), (second_url, second)] = relays;
    204     let first_requests = Arc::new(AtomicUsize::new(0));
    205     let second_requests = Arc::new(AtomicUsize::new(0));
    206     let first_task = tokio::spawn(serve(first, None, false, Arc::clone(&first_requests)));
    207     let second_task = tokio::spawn(serve(second, None, true, Arc::clone(&second_requests)));
    208     let (transport, request) = transport(&[first_url, second_url], 1);
    209     let page = tokio::time::timeout(Duration::from_secs(5), transport.fetch(request))
    210         .await
    211         .unwrap()
    212         .unwrap();
    213     first_task.abort();
    214     second_task.abort();
    215     assert_eq!(first_requests.load(Ordering::SeqCst), 1);
    216     assert_eq!(second_requests.load(Ordering::SeqCst), 0);
    217     assert_eq!(page.target_outcomes().len(), 2);
    218     assert!(
    219         page.target_outcomes()
    220             .iter()
    221             .all(|outcome| outcome.state() == FetchTargetState::Cancelled)
    222     );
    223 }
    224 
    225 #[tokio::test(flavor = "multi_thread")]
    226 async fn a_slow_relay_preserves_the_other_relays_completed_evidence_and_collected_events() {
    227     let (good, good_url) = listener().await;
    228     let (slow, slow_url) = listener().await;
    229     let good_event = event("complete relay");
    230     let slow_event = event("partial relay");
    231     let expected = [
    232         good_event["id"].as_str().unwrap().to_owned(),
    233         slow_event["id"].as_str().unwrap().to_owned(),
    234     ];
    235     let calls = Arc::new(AtomicUsize::new(0));
    236     let good_task = tokio::spawn(serve(good, Some(good_event), true, Arc::clone(&calls)));
    237     let slow_task = tokio::spawn(serve(slow, Some(slow_event), false, Arc::clone(&calls)));
    238     let (transport, request) = transport(&[good_url, slow_url], 2);
    239     let page = tokio::time::timeout(Duration::from_secs(5), transport.fetch(request))
    240         .await
    241         .unwrap()
    242         .unwrap();
    243     good_task.abort();
    244     slow_task.abort();
    245     assert_eq!(calls.load(Ordering::SeqCst), 2);
    246     assert_eq!(page.events().len(), 2);
    247     for id in expected {
    248         assert!(
    249             page.events()
    250                 .iter()
    251                 .any(|event| event.event().id_str() == id)
    252         );
    253     }
    254     assert_eq!(
    255         page.target_outcomes()
    256             .iter()
    257             .filter(|outcome| outcome.state() == FetchTargetState::Complete)
    258             .count(),
    259         1
    260     );
    261     assert_eq!(
    262         page.target_outcomes()
    263             .iter()
    264             .filter(|outcome| outcome.state() == FetchTargetState::Cancelled)
    265             .count(),
    266         1
    267     );
    268 }
    269 
    270 #[tokio::test(flavor = "multi_thread")]
    271 async fn oversized_wire_messages_never_become_completed_fetch_evidence() {
    272     let (listener, url) = listener().await;
    273     let server = tokio::spawn(async move {
    274         let (stream, _) = listener.accept().await.unwrap();
    275         let mut socket = accept_async(stream).await.unwrap();
    276         while let Some(message) = socket.next().await {
    277             let message = match message {
    278                 Ok(Message::Text(message)) => message,
    279                 Ok(Message::Close(_)) | Err(_) => return,
    280                 _ => continue,
    281             };
    282             let values: Value = serde_json::from_str(&message).unwrap();
    283             if values[0] == "REQ" {
    284                 let _ = socket
    285                     .send(Message::Text(
    286                         serde_json::to_string(&("NOTICE", "x".repeat(512 * 1024)))
    287                             .unwrap()
    288                             .into(),
    289                     ))
    290                     .await;
    291             }
    292         }
    293     });
    294     let (transport, request) = transport(&[url], 1);
    295     let page = tokio::time::timeout(Duration::from_secs(5), transport.fetch(request))
    296         .await
    297         .unwrap()
    298         .unwrap();
    299     tokio::time::timeout(Duration::from_secs(5), server)
    300         .await
    301         .unwrap()
    302         .unwrap();
    303     assert!(page.events().is_empty());
    304     assert_eq!(page.target_outcomes().len(), 1);
    305     assert_ne!(
    306         page.target_outcomes()[0].state(),
    307         FetchTargetState::Complete
    308     );
    309 }
    310 
    311 #[tokio::test(flavor = "multi_thread")]
    312 async fn dropping_a_polled_fetch_closes_the_subscription_or_connection() {
    313     let (listener, url) = listener().await;
    314     let (started, observed) = oneshot::channel();
    315     let server = tokio::spawn(async move {
    316         let (stream, _) = listener.accept().await.unwrap();
    317         let mut socket = accept_async(stream).await.unwrap();
    318         let mut started = Some(started);
    319         while let Some(message) = socket.next().await {
    320             let message = match message {
    321                 Ok(Message::Text(message)) => message,
    322                 Ok(Message::Close(_)) | Err(_) => return,
    323                 _ => continue,
    324             };
    325             let values: Value = serde_json::from_str(&message).unwrap();
    326             if values[0] == "REQ" {
    327                 started.take().unwrap().send(()).unwrap();
    328             } else if values[0] == "CLOSE" {
    329                 return;
    330             }
    331         }
    332     });
    333     let (transport, request) = transport(&[url], 1);
    334     let mut fetch = Box::pin(transport.fetch(request));
    335     tokio::time::timeout(Duration::from_secs(5), async {
    336         tokio::select! {
    337             _ = &mut fetch => panic!("fetch completed before its relay response"),
    338             result = observed => { result.unwrap(); }
    339         }
    340     })
    341     .await
    342     .unwrap();
    343     drop(fetch);
    344     tokio::time::timeout(Duration::from_secs(5), server)
    345         .await
    346         .unwrap()
    347         .unwrap();
    348 }