fetch_raw_budget.rs (10225B)
1 use futures::{SinkExt, StreamExt}; 2 use radroots_transport::{ 3 EventSource, FetchRequest, TargetSet, outcome::FetchTargetState, source::FetchBounds, 4 }; 5 use radroots_transport_nostr::{ 6 Config, NostrTransport, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, 7 RelayUrlPolicy, 8 }; 9 use serde_json::Value; 10 use std::time::{Duration, SystemTime, UNIX_EPOCH}; 11 use tokio::net::{TcpListener, TcpStream}; 12 use tokio_tungstenite::{WebSocketStream, accept_async, tungstenite::Message}; 13 14 const WATCHDOG: Duration = Duration::from_secs(10); 15 16 fn transport(urls: &[String]) -> (NostrTransport, FetchRequest) { 17 let profile = RelayProfile::explicit( 18 RelayProfileKind::Simulator, 19 urls.iter().map(|url| { 20 RelayEndpoint::new(url, RelayUrlPolicy::Local, RelayAccess::ReadOnly).unwrap() 21 }), 22 ) 23 .unwrap(); 24 let config = Config::from_profile(profile) 25 .with_timeouts(1000, 5000, 500) 26 .unwrap() 27 .with_max_connections(1) 28 .unwrap(); 29 let targets = TargetSet::new( 30 config 31 .read_relays() 32 .map(|relay| relay.to_target().unwrap()) 33 .collect(), 34 ) 35 .unwrap(); 36 let now = SystemTime::now() 37 .duration_since(UNIX_EPOCH) 38 .unwrap() 39 .as_millis() as u64; 40 let request = FetchRequest::new( 41 "raw-budget-loopback", 42 targets, 43 FetchBounds::new(10, now + 5000).unwrap(), 44 ) 45 .unwrap(); 46 ( 47 radroots_transport_nostr_native::create_transport(config), 48 request, 49 ) 50 } 51 52 async fn listener() -> (TcpListener, String) { 53 let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); 54 let url = format!("ws://{}", listener.local_addr().unwrap()); 55 (listener, url) 56 } 57 58 fn malformed_event() -> Value { 59 // Canonical primitive fields pass wire admission, while absent event 60 // fields still exercise malformed traffic in the aggregate ingress budget. 61 let value = serde_json::json!({ 62 "id": "00".repeat(32), 63 "pubkey": "11".repeat(32), 64 "sig": "22".repeat(64), 65 "invalid_event": "x".repeat(384 * 1024), 66 }); 67 assert!(serde_json::from_value::<nostr_sdk::prelude::Event>(value.clone()).is_err()); 68 value 69 } 70 71 // A WebSocket pong is produced only after the client's receive stream has 72 // consumed all preceding messages. No scheduling sleep is an admission barrier. 73 async fn barrier(socket: &mut WebSocketStream<TcpStream>, sequence: usize) -> bool { 74 let marker = sequence.to_be_bytes().to_vec(); 75 if socket 76 .send(Message::Ping(marker.clone().into())) 77 .await 78 .is_err() 79 { 80 return false; 81 } 82 while let Some(message) = socket.next().await { 83 match message { 84 Ok(Message::Pong(value)) if value.as_ref() == marker.as_slice() => return true, 85 Ok(Message::Close(_)) | Err(_) => return false, 86 _ => { 87 if socket.flush().await.is_err() { 88 return false; 89 } 90 } 91 } 92 } 93 false 94 } 95 96 async fn serve_malformed(listener: TcpListener, frames: usize) { 97 let (stream, _) = listener.accept().await.unwrap(); 98 let mut socket = accept_async(stream).await.unwrap(); 99 while let Some(message) = socket.next().await { 100 let text = match message { 101 Ok(Message::Text(text)) => text, 102 Ok(Message::Close(_)) | Err(_) => return, 103 _ => { 104 let _ = socket.flush().await; 105 continue; 106 } 107 }; 108 let values: Value = serde_json::from_str(&text).unwrap(); 109 if values[0] != "REQ" { 110 continue; 111 } 112 let malformed = serde_json::to_string(&("EVENT", &values[1], malformed_event())).unwrap(); 113 assert!(malformed.len() < 512 * 1024); 114 for sequence in 0..frames { 115 if socket 116 .send(Message::Text(malformed.clone().into())) 117 .await 118 .is_err() 119 || !barrier(&mut socket, sequence).await 120 { 121 return; 122 } 123 } 124 if socket 125 .send(Message::Text( 126 serde_json::to_string(&("EOSE", &values[1])).unwrap().into(), 127 )) 128 .await 129 .is_err() 130 { 131 return; 132 } 133 } 134 } 135 136 async fn fetch_malformed(frames: usize) -> FetchTargetState { 137 let (listener, url) = listener().await; 138 let server = tokio::spawn(serve_malformed(listener, frames)); 139 let (transport, request) = transport(&[url]); 140 let result = tokio::time::timeout(WATCHDOG, transport.fetch(request)).await; 141 server.abort(); 142 let joined = server.await; 143 assert!(joined.is_ok() || joined.unwrap_err().is_cancelled()); 144 let page = result.unwrap().unwrap(); 145 assert!(page.events().is_empty()); 146 assert_eq!(page.target_outcomes().len(), 1); 147 page.target_outcomes()[0].state() 148 } 149 150 #[tokio::test(flavor = "multi_thread")] 151 async fn empty_eose_remains_complete_with_raw_ingress_accounting() { 152 assert_eq!(fetch_malformed(0).await, FetchTargetState::Complete); 153 } 154 155 #[tokio::test(flavor = "multi_thread")] 156 async fn malformed_event_traffic_exhausts_raw_budget_before_eose() { 157 assert_eq!(fetch_malformed(24).await, FetchTargetState::Partial); 158 } 159 160 async fn finish_server(mut server: tokio::task::JoinHandle<()>) { 161 let result = tokio::time::timeout(WATCHDOG, &mut server).await; 162 if result.is_err() { 163 server.abort(); 164 let _ = server.await; 165 } 166 result 167 .expect("client must close the bounded relay connection") 168 .unwrap(); 169 } 170 171 #[tokio::test(flavor = "multi_thread")] 172 async fn completed_batches_do_not_refund_raw_bytes_for_later_relays() { 173 let (one, one_url) = listener().await; 174 let (two, two_url) = listener().await; 175 let servers = [ 176 tokio::spawn(serve_malformed(one, 12)), 177 tokio::spawn(serve_malformed(two, 12)), 178 ]; 179 let (transport, request) = transport(&[one_url, two_url]); 180 let result = tokio::time::timeout(WATCHDOG, transport.fetch(request)).await; 181 for server in servers { 182 finish_server(server).await; 183 } 184 let page = result.unwrap().unwrap(); 185 assert!(page.events().is_empty()); 186 assert_eq!( 187 page.target_outcomes() 188 .iter() 189 .filter(|outcome| outcome.state() == FetchTargetState::Complete) 190 .count(), 191 1 192 ); 193 assert_eq!( 194 page.target_outcomes() 195 .iter() 196 .filter(|outcome| outcome.state() == FetchTargetState::Partial) 197 .count(), 198 1 199 ); 200 } 201 202 #[tokio::test(flavor = "multi_thread")] 203 async fn unsolicited_malformed_traffic_is_bounded_before_the_request() { 204 let (listener, url) = listener().await; 205 let server = tokio::spawn(async move { 206 let (stream, _) = listener.accept().await.unwrap(); 207 let mut socket = accept_async(stream).await.unwrap(); 208 let malformed = 209 serde_json::to_string(&("EVENT", "unsolicited", malformed_event())).unwrap(); 210 for sequence in 0..24 { 211 if socket 212 .send(Message::Text(malformed.clone().into())) 213 .await 214 .is_err() 215 || !barrier(&mut socket, sequence).await 216 { 217 return; 218 } 219 } 220 panic!("oversized unsolicited inventory must close before admission"); 221 }); 222 let (transport, request) = transport(&[url]); 223 let result = tokio::time::timeout(WATCHDOG, transport.fetch(request)).await; 224 finish_server(server).await; 225 assert_eq!( 226 result.unwrap().unwrap().target_outcomes()[0].state(), 227 FetchTargetState::Partial 228 ); 229 } 230 231 #[tokio::test(flavor = "multi_thread")] 232 async fn zero_payload_continuation_frames_consume_work_before_message_decoding() { 233 use tokio_tungstenite::tungstenite::protocol::frame::{ 234 Frame, 235 coding::{Data, OpCode}, 236 }; 237 let (listener, url) = listener().await; 238 let server = tokio::spawn(async move { 239 let (stream, _) = listener.accept().await.unwrap(); 240 let mut socket = accept_async(stream).await.unwrap(); 241 while let Some(message) = socket.next().await { 242 let text = match message { 243 Ok(Message::Text(text)) => text, 244 Ok(Message::Close(_)) | Err(_) => return, 245 _ => { 246 let _ = socket.flush().await; 247 continue; 248 } 249 }; 250 let values: Value = serde_json::from_str(&text).unwrap(); 251 if values[0] != "REQ" { 252 continue; 253 } 254 socket 255 .send(Message::Frame(Frame::message( 256 Vec::new(), 257 OpCode::Data(Data::Text), 258 false, 259 ))) 260 .await 261 .unwrap(); 262 for sequence in 0..8193 { 263 if socket 264 .send(Message::Frame(Frame::message( 265 Vec::new(), 266 OpCode::Data(Data::Continue), 267 false, 268 ))) 269 .await 270 .is_err() 271 { 272 return; 273 } 274 if sequence % 128 == 0 && !barrier(&mut socket, sequence).await { 275 return; 276 } 277 } 278 if socket 279 .send(Message::Frame(Frame::message( 280 b"[]".to_vec(), 281 OpCode::Data(Data::Continue), 282 true, 283 ))) 284 .await 285 .is_err() 286 { 287 return; 288 } 289 let _ = socket 290 .send(Message::Text( 291 serde_json::to_string(&("EOSE", &values[1])).unwrap().into(), 292 )) 293 .await; 294 } 295 }); 296 let (transport, request) = transport(&[url]); 297 let result = tokio::time::timeout(WATCHDOG, transport.fetch(request)).await; 298 finish_server(server).await; 299 let page = result.unwrap().unwrap(); 300 assert!(page.events().is_empty()); 301 assert_eq!(page.target_outcomes()[0].state(), FetchTargetState::Partial); 302 }