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 }