lib.rs (13594B)
1 #![forbid(unsafe_code)] 2 3 mod clock; 4 mod shared; 5 6 use futures::{FutureExt, task::AtomicWaker}; 7 use radroots_transport::host::websocket::{Admission, Connector, Error, Frame, Socket}; 8 use radroots_transport_nostr_browser::BrowserConnector; 9 use std::{ 10 net::IpAddr, 11 num::NonZeroUsize, 12 sync::{ 13 Arc, 14 atomic::{AtomicBool, AtomicUsize, Ordering}, 15 }, 16 task::Context, 17 time::Duration, 18 }; 19 use wasm_bindgen::prelude::*; 20 21 #[wasm_bindgen] 22 extern "C" { 23 #[wasm_bindgen(js_namespace = globalThis, js_name = waitForBrowserSocketClose)] 24 fn wait_for_close(route: &str) -> js_sys::Promise; 25 #[wasm_bindgen(js_namespace = globalThis, js_name = forceBrowserSocketBackpressure)] 26 fn force_backpressure(); 27 } 28 29 struct Grant { 30 live: AtomicBool, 31 charge: AtomicBool, 32 bytes: AtomicUsize, 33 frames: AtomicUsize, 34 reader: AtomicWaker, 35 writer: AtomicWaker, 36 } 37 impl Grant { 38 fn new() -> Arc<Self> { 39 Arc::new(Self { 40 live: AtomicBool::new(true), 41 charge: AtomicBool::new(true), 42 bytes: AtomicUsize::new(0), 43 frames: AtomicUsize::new(0), 44 reader: AtomicWaker::new(), 45 writer: AtomicWaker::new(), 46 }) 47 } 48 fn revoke(&self) { 49 self.live.store(false, Ordering::SeqCst); 50 self.reader.wake(); 51 self.writer.wake(); 52 } 53 } 54 impl Admission for Grant { 55 fn permits_address(&self, _: IpAddr) -> bool { 56 self.live.load(Ordering::SeqCst) 57 } 58 fn admitted_read(&self, context: &Context<'_>) -> bool { 59 self.reader.register(context.waker()); 60 self.live.load(Ordering::SeqCst) 61 } 62 fn admitted_write(&self, context: &Context<'_>) -> bool { 63 self.writer.register(context.waker()); 64 self.live.load(Ordering::SeqCst) 65 } 66 fn charge(&self, bytes: usize, frames: usize, data: usize) -> bool { 67 assert_eq!(frames, data); 68 self.bytes.fetch_add(bytes, Ordering::SeqCst); 69 self.frames.fetch_add(frames, Ordering::SeqCst); 70 self.charge.load(Ordering::SeqCst) && self.live.load(Ordering::SeqCst) 71 } 72 } 73 fn check(value: bool, name: &str) -> Result<(), JsValue> { 74 if value { 75 Ok(()) 76 } else { 77 Err(JsValue::from_str(name)) 78 } 79 } 80 fn error(value: Error) -> JsValue { 81 JsValue::from_str(&value.to_string()) 82 } 83 async fn pause() { 84 async_utility::time::sleep(Duration::from_millis(40)).await; 85 } 86 async fn connect( 87 base: &str, 88 route: &str, 89 limit: usize, 90 grant: Arc<Grant>, 91 ) -> Result<Arc<dyn Socket>, JsValue> { 92 BrowserConnector::default() 93 .connect( 94 &format!("{base}/{route}"), 95 Duration::from_secs(2), 96 NonZeroUsize::new(limit).unwrap(), 97 grant, 98 ) 99 .await 100 .map_err(error) 101 } 102 103 #[wasm_bindgen] 104 pub async fn verify_socket(base: String) -> Result<js_sys::Array, JsValue> { 105 let passed = js_sys::Array::new(); 106 let connector = BrowserConnector::default(); 107 let grant = Grant::new(); 108 let endpoint = format!("{base}/unpolled"); 109 let future = connector.connect( 110 &endpoint, 111 Duration::from_secs(1), 112 NonZeroUsize::new(1024).unwrap(), 113 grant.clone(), 114 ); 115 drop(future); 116 pause().await; 117 passed.push(&"unpolled inert".into()); 118 119 let endpoint = format!("{base}/cancelled-owner"); 120 let mut attempt = connector.connect( 121 &endpoint, 122 Duration::from_secs(1), 123 NonZeroUsize::new(1).unwrap(), 124 Grant::new(), 125 ); 126 check( 127 attempt.as_mut().now_or_never().is_none(), 128 "owner initially scheduled", 129 )?; 130 drop(attempt); 131 pause().await; 132 passed.push(&"cancellation before owner startup".into()); 133 134 let endpoint = format!("{base}/revoked-owner"); 135 let revoked_grant = Grant::new(); 136 let mut attempt = connector.connect( 137 &endpoint, 138 Duration::from_secs(1), 139 NonZeroUsize::new(1).unwrap(), 140 revoked_grant.clone(), 141 ); 142 check( 143 attempt.as_mut().now_or_never().is_none(), 144 "revocable owner initially scheduled", 145 )?; 146 revoked_grant.revoke(); 147 check( 148 matches!(attempt.await, Err(Error::Policy)), 149 "owner rechecks original grant", 150 )?; 151 passed.push(&"revocation before owner startup".into()); 152 153 let endpoint = format!("{base}/expired-owner"); 154 let mut attempt = connector.connect( 155 &endpoint, 156 Duration::from_millis(5), 157 NonZeroUsize::new(1).unwrap(), 158 Grant::new(), 159 ); 160 check( 161 attempt.as_mut().now_or_never().is_none(), 162 "deadline owner initially scheduled", 163 )?; 164 let until = js_sys::Date::now() + 25.0; 165 while js_sys::Date::now() < until {} 166 check( 167 matches!(attempt.await, Err(Error::Timeout)), 168 "delayed owner cannot renew original deadline", 169 )?; 170 passed.push(&"original deadline before owner startup".into()); 171 172 let socket = connect(&base, "echo", 1024, grant.clone()).await?; 173 let text = Frame::Text(" [\"original\", 7, \"café🌱\"] \n".into()); 174 socket.send(text.clone()).await.map_err(error)?; 175 check( 176 socket.receive().await.map_err(error)? == Some(text), 177 "original text", 178 )?; 179 let binary = Frame::Binary(vec![0, 255, 10, 13, 128]); 180 socket.send(binary.clone()).await.map_err(error)?; 181 check( 182 socket.receive().await.map_err(error)? == Some(binary), 183 "original binary", 184 )?; 185 check( 186 grant.frames.load(Ordering::SeqCst) == 2 && grant.bytes.load(Ordering::SeqCst) > 5, 187 "original admission charges", 188 )?; 189 passed.push(&"original text binary and admission".into()); 190 for frame in [Frame::Ping(vec![]), Frame::Pong(vec![]), Frame::Close(None)] { 191 check( 192 socket.send(frame).await == Err(Error::Unsupported), 193 "unsupported control", 194 )?; 195 } 196 check(!connector.supports_ping(), "browser ping unavailable")?; 197 check( 198 socket.send(Frame::Binary(vec![0; 1025])).await == Err(Error::Protocol), 199 "outgoing size", 200 )?; 201 passed.push(&"control and outgoing bounds".into()); 202 203 let mut pending = socket.send(Frame::Text("observer lost".into())); 204 check( 205 pending.as_mut().now_or_never().is_none(), 206 "admitted send starts pending", 207 )?; 208 drop(pending); 209 check( 210 socket.send(Frame::Text("cannot replace".into())).await == Err(Error::Policy), 211 "cancelled observer cannot replace accepted send", 212 )?; 213 check( 214 socket.receive().await.map_err(error)? == Some(Frame::Text("observer lost".into())), 215 "original admitted send retained", 216 )?; 217 passed.push(&"send observer cancellation".into()); 218 219 let mut pending = socket.receive(); 220 check(pending.as_mut().now_or_never().is_none(), "pending receive")?; 221 let revoking = grant.clone(); 222 wasm_bindgen_futures::spawn_local(async move { 223 async_utility::time::sleep(Duration::from_millis(10)).await; 224 revoking.revoke(); 225 }); 226 check( 227 pending.await == Err(Error::Policy), 228 "revocation wakes original reader", 229 )?; 230 check( 231 socket.send(Frame::Text("denied".into())).await.is_err(), 232 "revoked send", 233 )?; 234 socket.close().await.map_err(error)?; 235 socket.close().await.map_err(error)?; 236 drop(socket); 237 passed.push(&"revocation and repeated cleanup".into()); 238 239 for (route, limit, expected) in [ 240 ("oversize", 1024, Error::Protocol), 241 ("unicode", 1024, Error::Protocol), 242 ("binary-large", 1024, Error::Protocol), 243 ("items", 1024, Error::Policy), 244 ("bytes", 512 * 1024, Error::Policy), 245 ] { 246 let socket = connect(&base, route, limit, Grant::new()).await?; 247 wasm_bindgen_futures::JsFuture::from(wait_for_close(route)).await?; 248 check(socket.receive().await == Err(expected), route)?; 249 socket.close().await.map_err(error)?; 250 passed.push(&JsValue::from_str(route)); 251 } 252 let grant = Grant::new(); 253 grant.charge.store(false, Ordering::SeqCst); 254 let socket = connect(&base, "echo", 1024, grant.clone()).await?; 255 socket 256 .send(Frame::Text("original refusal".into())) 257 .await 258 .map_err(error)?; 259 check( 260 socket.receive().await == Err(Error::Policy), 261 "original budget refuses callback", 262 )?; 263 check( 264 grant.bytes.load(Ordering::SeqCst) == 16, 265 "refused original bytes charged", 266 )?; 267 socket.close().await.map_err(error)?; 268 passed.push(&"original budget refusal".into()); 269 270 let socket = connect(&base, "echo", 1024, Grant::new()).await?; 271 force_backpressure(); 272 check( 273 socket.send(Frame::Text("must not enqueue".into())).await == Err(Error::Policy), 274 "reported browser outbound credit", 275 )?; 276 socket.close().await.map_err(error)?; 277 passed.push(&"reported outbound buffer refusal".into()); 278 279 let socket = connect(&base, "disconnect", 1024, Grant::new()).await?; 280 check( 281 socket.receive().await.map_err(error)? == Some(Frame::Text("before close".into())), 282 "retained before peer close", 283 )?; 284 check( 285 socket.receive().await.map_err(error)?.is_none(), 286 "peer end observed", 287 )?; 288 socket.close().await.map_err(error)?; 289 passed.push(&"peer disconnect preserves preceding message".into()); 290 291 let socket = connect(&base, "echo", 1024, Grant::new()).await?; 292 drop(socket); 293 pause().await; 294 passed.push(&"last socket observer cleanup".into()); 295 296 let endpoint = format!("{base}/stall"); 297 let mut attempt = connector.connect( 298 &endpoint, 299 Duration::from_secs(2), 300 NonZeroUsize::new(1).unwrap(), 301 Grant::new(), 302 ); 303 check( 304 attempt.as_mut().now_or_never().is_none(), 305 "connect initially pending", 306 )?; 307 pause().await; 308 drop(attempt); 309 pause().await; 310 passed.push(&"cancelled handshake cleanup".into()); 311 let result = connector 312 .connect( 313 &endpoint, 314 Duration::from_millis(20), 315 NonZeroUsize::new(1).unwrap(), 316 Grant::new(), 317 ) 318 .await; 319 check( 320 matches!(result, Err(Error::Timeout)), 321 "original handshake deadline", 322 )?; 323 passed.push(&"handshake deadline cleanup".into()); 324 pause().await; 325 Ok(passed) 326 } 327 328 #[wasm_bindgen] 329 pub async fn verify_scope(base: String) -> Result<js_sys::Array, JsValue> { 330 let passed = js_sys::Array::new(); 331 let connector = BrowserConnector::default(); 332 let sibling = BrowserConnector::default(); 333 let endpoint = format!("{base}/echo"); 334 let limit = NonZeroUsize::new(1024).unwrap(); 335 let a = connector 336 .connect(&endpoint, Duration::from_secs(2), limit, Grant::new()) 337 .await 338 .map_err(error)?; 339 let b = connector 340 .connect(&endpoint, Duration::from_secs(2), limit, Grant::new()) 341 .await 342 .map_err(error)?; 343 let other = sibling 344 .connect(&endpoint, Duration::from_secs(2), limit, Grant::new()) 345 .await 346 .map_err(error)?; 347 let (socket_done, scope_done) = futures::join!(a.close(), connector.close()); 348 socket_done.map_err(error)?; 349 scope_done.map_err(error)?; 350 check( 351 b.receive().await.map_err(error)?.is_none(), 352 "all original scope sockets disposed", 353 )?; 354 check( 355 b.send(Frame::Text("closed".into())).await == Err(Error::Closed), 356 "scope cannot send after disposal", 357 )?; 358 let denied = connector 359 .connect(&endpoint, Duration::from_secs(2), limit, Grant::new()) 360 .await; 361 check( 362 matches!(denied, Err(Error::Closed)), 363 "closed scope cannot admit another original owner", 364 )?; 365 passed.push(&"concurrent socket and scope disposal".into()); 366 other 367 .send(Frame::Text("isolated scope".into())) 368 .await 369 .map_err(error)?; 370 check( 371 other.receive().await.map_err(error)? == Some(Frame::Text("isolated scope".into())), 372 "sibling scope remains live", 373 )?; 374 let copy = sibling.clone(); 375 let (first, second) = futures::join!(sibling.close(), copy.close()); 376 first.map_err(error)?; 377 second.map_err(error)?; 378 passed.push(&"scope isolation and shared clone closure".into()); 379 380 let connector = BrowserConnector::default(); 381 let stalled = format!("{base}/stall"); 382 let mut attempt = connector.connect(&stalled, Duration::from_secs(2), limit, Grant::new()); 383 check( 384 attempt.as_mut().now_or_never().is_none(), 385 "original pending scope handshake", 386 )?; 387 pause().await; 388 let mut closing = connector.close(); 389 check( 390 closing.as_mut().now_or_never().is_none(), 391 "scope close starts pending before original owner disposal", 392 )?; 393 drop(closing); 394 check( 395 matches!(attempt.await, Err(Error::Closed)), 396 "original handshake refused by scope close", 397 )?; 398 connector.close().await.map_err(error)?; 399 passed.push(&"cancelled scope close resumes original disposal".into()); 400 401 let connector = BrowserConnector::default(); 402 let inert = format!("{base}/closed-owner"); 403 let mut attempt = connector.connect(&inert, Duration::from_secs(2), limit, Grant::new()); 404 check( 405 attempt.as_mut().now_or_never().is_none(), 406 "deferred original scope owner", 407 )?; 408 let (attempt, closed) = futures::join!(attempt, connector.close()); 409 check( 410 matches!(attempt, Err(Error::Closed)), 411 "scope refuses before DOM owner starts", 412 )?; 413 closed.map_err(error)?; 414 passed.push(&"scope close before DOM owner startup".into()); 415 Ok(passed) 416 }