local_io.rs (14240B)
1 use futures::{SinkExt, StreamExt}; 2 use radroots_transport::{ 3 EventSource, EventSubscriber, FetchRequest, SubscriptionNext, SubscriptionRequest, TargetSet, 4 capability::Availability, 5 outcome::FetchTargetState, 6 source::{FetchBounds, SubscriptionBounds, SubscriptionEndReason}, 7 }; 8 use radroots_transport_nostr::{ 9 Config, RelayAccess, RelayAggregateState, RelayEndpoint, RelayEvidenceState, RelayProfile, 10 RelayProfileKind, RelayUrlPolicy, 11 }; 12 use serde_json::Value; 13 use std::time::{Duration, SystemTime, UNIX_EPOCH}; 14 use tokio::net::TcpListener; 15 use tokio_tungstenite::{accept_async, tungstenite::Message}; 16 17 const FIXTURE_SECRET_KEY: &str = "0000000000000000000000000000000000000000000000000000000000000001"; 18 19 #[tokio::test(flavor = "multi_thread")] 20 async fn simulator_profile_proves_read_capability_against_a_real_loopback_socket() { 21 let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind relay"); 22 let address = listener.local_addr().expect("relay address"); 23 let relay_url = format!("ws://{address}"); 24 let server = tokio::spawn(async move { 25 let (stream, _) = listener.accept().await.expect("accept relay client"); 26 let mut websocket = accept_async(stream).await.expect("websocket handshake"); 27 while let Some(message) = websocket.next().await { 28 let Message::Text(message) = message.expect("client message") else { 29 continue; 30 }; 31 let parsed: Value = serde_json::from_str(message.as_str()).expect("Nostr message"); 32 let Some(values) = parsed.as_array() else { 33 continue; 34 }; 35 let [Value::String(kind), Value::String(subscription), ..] = values.as_slice() else { 36 continue; 37 }; 38 if kind == "REQ" { 39 websocket 40 .send(Message::Text( 41 serde_json::to_string(&("EOSE", subscription)) 42 .expect("EOSE message") 43 .into(), 44 )) 45 .await 46 .expect("send EOSE"); 47 break; 48 } 49 } 50 }); 51 52 let endpoint = RelayEndpoint::new( 53 relay_url.as_str(), 54 RelayUrlPolicy::Local, 55 RelayAccess::ReadWrite, 56 ) 57 .expect("loopback endpoint"); 58 let profile = 59 RelayProfile::explicit(RelayProfileKind::Simulator, [endpoint]).expect("simulator profile"); 60 let config = Config::from_profile(profile) 61 .with_timeouts(1_000, 2_000, 500) 62 .expect("timeouts"); 63 let targets = TargetSet::new( 64 config 65 .read_relays() 66 .map(|relay| relay.to_target()) 67 .collect::<Result<Vec<_>, _>>() 68 .expect("targets"), 69 ) 70 .expect("target set"); 71 let request = FetchRequest::new( 72 "local-real-io", 73 targets, 74 FetchBounds::new(1, unix_time_ms() + 5_000).expect("bounds"), 75 ) 76 .expect("request"); 77 let transport = radroots_transport_nostr_native::create_transport(config); 78 let page = tokio::time::timeout(Duration::from_secs(5), transport.fetch(request)) 79 .await 80 .expect("bounded fetch") 81 .expect("fetch page"); 82 83 assert!(page.events().is_empty()); 84 assert_eq!(page.target_outcomes().len(), 1); 85 assert_eq!( 86 page.target_outcomes()[0].state(), 87 FetchTargetState::Complete 88 ); 89 let status = transport.relay_status(); 90 assert_eq!(status.state(), RelayAggregateState::ReadOnly); 91 assert_eq!(status.read_availability(), Availability::Available); 92 assert_eq!(status.write_availability(), Availability::Unavailable); 93 assert_eq!( 94 status.relays()[0].read().state(), 95 RelayEvidenceState::Available 96 ); 97 assert_eq!( 98 status.relays()[0].write().state(), 99 RelayEvidenceState::Unobserved 100 ); 101 server.await.expect("relay task"); 102 } 103 104 #[tokio::test(flavor = "multi_thread")] 105 async fn simulator_profile_streams_and_cancels_a_real_live_subscription() { 106 use nostr_sdk::prelude::{EventBuilder, FinalizeEvent, Keys, Kind, Timestamp}; 107 108 let event = EventBuilder::new(Kind::TextNote, "bounded live event") 109 .custom_created_at(Timestamp::from_secs(1_800_000_100)) 110 .finalize(&Keys::parse(FIXTURE_SECRET_KEY).expect("fixture keys")) 111 .expect("signed event"); 112 let expected_id = event.id.to_hex(); 113 let event: Value = serde_json::from_str(event.as_json().as_str()).expect("event JSON"); 114 let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind relay"); 115 let address = listener.local_addr().expect("relay address"); 116 let relay_url = format!("ws://{address}"); 117 let server = tokio::spawn(async move { 118 let (stream, _) = listener.accept().await.expect("accept relay client"); 119 let mut websocket = accept_async(stream).await.expect("websocket handshake"); 120 let mut subscription_id = None; 121 while let Some(message) = websocket.next().await { 122 let Message::Text(message) = message.expect("client message") else { 123 continue; 124 }; 125 let parsed: Value = serde_json::from_str(message.as_str()).expect("Nostr message"); 126 let Some(values) = parsed.as_array() else { 127 continue; 128 }; 129 match values.as_slice() { 130 [Value::String(kind), Value::String(subscription), ..] if kind == "REQ" => { 131 subscription_id = Some(subscription.clone()); 132 websocket 133 .send(Message::Text( 134 serde_json::to_string(&("EVENT", subscription, &event)) 135 .expect("EVENT message") 136 .into(), 137 )) 138 .await 139 .expect("send EVENT"); 140 } 141 [Value::String(kind), Value::String(subscription)] 142 if kind == "CLOSE" && subscription_id.as_ref() == Some(subscription) => 143 { 144 return; 145 } 146 _ => {} 147 } 148 } 149 panic!("client disconnected without CLOSE"); 150 }); 151 152 let endpoint = RelayEndpoint::new( 153 relay_url.as_str(), 154 RelayUrlPolicy::Local, 155 RelayAccess::ReadWrite, 156 ) 157 .expect("loopback endpoint"); 158 let profile = 159 RelayProfile::explicit(RelayProfileKind::Simulator, [endpoint]).expect("simulator profile"); 160 let config = Config::from_profile(profile) 161 .with_timeouts(1_000, 2_000, 500) 162 .expect("timeouts"); 163 let targets = TargetSet::new( 164 config 165 .read_relays() 166 .map(|relay| relay.to_target()) 167 .collect::<Result<Vec<_>, _>>() 168 .expect("targets"), 169 ) 170 .expect("target set"); 171 let request = SubscriptionRequest::new( 172 "local-live-io", 173 targets, 174 SubscriptionBounds::new(2, unix_time_ms() + 5_000).expect("bounds"), 175 ) 176 .expect("request"); 177 let transport = radroots_transport_nostr_native::create_transport(config); 178 let mut subscription = 179 tokio::time::timeout(Duration::from_secs(5), transport.subscribe(request)) 180 .await 181 .expect("bounded subscribe") 182 .expect("subscription"); 183 let SubscriptionNext::Event(observed) = 184 tokio::time::timeout(Duration::from_secs(5), subscription.next()) 185 .await 186 .expect("bounded event") 187 .expect("event") 188 else { 189 panic!("event expected"); 190 }; 191 assert_eq!(observed.observed().event().id_str(), expected_id); 192 assert_eq!( 193 subscription.cancel().await.expect("cancel").reason(), 194 SubscriptionEndReason::Cancelled 195 ); 196 tokio::time::timeout(Duration::from_secs(5), server) 197 .await 198 .expect("server deadline") 199 .expect("relay task"); 200 } 201 202 #[tokio::test(flavor = "multi_thread", worker_threads = 2)] 203 async fn shutdown_disconnects_the_shared_live_pool_and_refuses_new_effects() { 204 use nostr_sdk::prelude::{EventBuilder, FinalizeEvent, Keys, Kind}; 205 use radroots_transport::{ 206 DeliveryRequest, EventSink, 207 policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy}, 208 sink::DeliveryPayload, 209 }; 210 211 let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); 212 let relay_url = format!("ws://{}", listener.local_addr().unwrap()); 213 let mut server = tokio::spawn(async move { 214 let (stream, _) = listener.accept().await.unwrap(); 215 let mut socket = accept_async(stream).await.unwrap(); 216 while let Some(message) = socket.next().await { 217 match message { 218 Ok(Message::Text(message)) => { 219 let value: Value = serde_json::from_str(&message).unwrap(); 220 if value[0] == "REQ" { 221 socket 222 .send(Message::Text( 223 serde_json::to_string(&("EOSE", &value[1])).unwrap().into(), 224 )) 225 .await 226 .unwrap(); 227 } 228 } 229 Ok(Message::Close(_)) | Err(_) => return listener, 230 _ => {} 231 } 232 } 233 listener 234 }); 235 let profile = RelayProfile::explicit( 236 RelayProfileKind::Simulator, 237 [RelayEndpoint::new(&relay_url, RelayUrlPolicy::Local, RelayAccess::ReadWrite).unwrap()], 238 ) 239 .unwrap(); 240 let config = Config::from_profile(profile) 241 .with_timeouts(1000, 2000, 500) 242 .unwrap(); 243 let relay = config.relays()[0].clone(); 244 let targets = TargetSet::new(vec![relay.to_target().unwrap()]).unwrap(); 245 let fetch = FetchRequest::new( 246 "shutdown-fetch", 247 targets.clone(), 248 FetchBounds::new(1, unix_time_ms() + 5000).unwrap(), 249 ) 250 .unwrap(); 251 let subscription = SubscriptionRequest::new( 252 "shutdown-subscription", 253 targets.clone(), 254 SubscriptionBounds::new(1, unix_time_ms() + 5000).unwrap(), 255 ) 256 .unwrap(); 257 let event = EventBuilder::new(Kind::TextNote, "synthetic shutdown fixture") 258 .finalize(&Keys::parse(FIXTURE_SECRET_KEY).unwrap()) 259 .unwrap(); 260 let delivery = DeliveryRequest::new( 261 "shutdown-delivery", 262 DeliveryPayload::new(radroots_event_codec::decode::signed_event(&event.as_json()).unwrap()), 263 targets, 264 SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), 265 unix_time_ms() + 5000, 266 ) 267 .unwrap(); 268 let transport = radroots_transport_nostr_native::create_transport(config); 269 let prepared = transport.prepare_delivery(delivery.clone()).unwrap(); 270 transport 271 .begin_authentication(&relay, "shutdown challenge", 1000, 2000) 272 .unwrap(); 273 let page = tokio::time::timeout(Duration::from_secs(5), transport.fetch(fetch.clone())) 274 .await 275 .unwrap() 276 .unwrap(); 277 assert_eq!( 278 page.target_outcomes()[0].state(), 279 FetchTargetState::Complete 280 ); 281 282 let mut live = transport.subscribe(subscription.clone()).await.unwrap(); 283 assert!( 284 !server.is_finished(), 285 "the pool must still own a live socket before shutdown" 286 ); 287 288 drop(transport.shutdown()); 289 assert!(EventSource::status(&transport).await.is_ok()); 290 let clone = transport.clone(); 291 clone.shutdown().await; 292 transport.shutdown().await; 293 let joined = tokio::time::timeout(Duration::from_secs(2), &mut server).await; 294 if joined.is_err() { 295 server.abort(); 296 let _ = server.await; 297 panic!("shutdown did not terminate the live loopback socket"); 298 } 299 let listener = joined.unwrap().unwrap(); 300 let ended = tokio::time::timeout(Duration::from_secs(2), live.next()) 301 .await 302 .unwrap() 303 .unwrap(); 304 assert!( 305 matches!(ended, SubscriptionNext::End(ref end) if end.reason() == SubscriptionEndReason::SourceClosed) 306 ); 307 assert_eq!( 308 transport.fetch(fetch).await.unwrap_err(), 309 radroots_transport::Error::TransportClosed 310 ); 311 assert!(matches!( 312 transport.subscribe(subscription).await, 313 Err(radroots_transport::Error::TransportClosed) 314 )); 315 assert_eq!( 316 EventSource::status(&clone).await.unwrap_err(), 317 radroots_transport::Error::TransportClosed 318 ); 319 assert_eq!( 320 EventSink::status(&clone).await.unwrap_err(), 321 radroots_transport::Error::TransportClosed 322 ); 323 assert_eq!( 324 transport 325 .begin_authentication(&relay, "new challenge", 1000, 2000) 326 .unwrap_err(), 327 radroots_transport_nostr::Error::TransportClosed 328 ); 329 assert_eq!( 330 transport 331 .complete_authentication(&relay, "shutdown challenge", None, 1500) 332 .await 333 .unwrap_err(), 334 radroots_transport_nostr::Error::TransportClosed 335 ); 336 assert_eq!( 337 transport 338 .reject_authentication(&relay, "shutdown challenge") 339 .unwrap_err(), 340 radroots_transport_nostr::Error::TransportClosed 341 ); 342 for failure in [ 343 transport 344 .execute_prepared_delivery(prepared) 345 .await 346 .unwrap_err(), 347 transport.deliver(delivery.clone()).await.unwrap_err(), 348 transport 349 .deliver_selected(delivery.clone(), delivery.target_set().clone()) 350 .await 351 .unwrap_err(), 352 ] { 353 assert_eq!(failure.code(), "transport_closed"); 354 failure.validate_for_request(&delivery).unwrap(); 355 assert_eq!( 356 failure.partial_evidence().len(), 357 delivery.target_set().len() 358 ); 359 assert!( 360 failure 361 .partial_evidence() 362 .iter() 363 .all(|row| !row.was_attempted()) 364 ); 365 } 366 assert!( 367 tokio::time::timeout(Duration::from_millis(150), listener.accept()) 368 .await 369 .is_err() 370 ); 371 } 372 373 fn unix_time_ms() -> u64 { 374 SystemTime::now() 375 .duration_since(UNIX_EPOCH) 376 .map(|duration| u64::try_from(duration.as_millis()).unwrap_or(u64::MAX)) 377 .unwrap_or_default() 378 }