browser.rs (12114B)
1 use crate::state::{MAX_QUEUE_BYTES, SendRequest, Shared, Status, payload_len}; 2 use futures::{ 3 channel::oneshot, 4 future::{Either, poll_fn, select}, 5 lock::Mutex, 6 }; 7 use radroots_transport::host::websocket::{Admission, Error, Frame, IoFuture, Socket}; 8 use std::{num::NonZeroUsize, pin::pin, sync::Arc, task::Poll, time::Duration}; 9 use wasm_bindgen::{JsCast, closure::Closure}; 10 use web_sys::{BinaryType, Event, MessageEvent, WebSocket}; 11 use web_time::Instant; 12 13 pub(crate) async fn connect( 14 endpoint: &str, 15 timeout: Duration, 16 limit: NonZeroUsize, 17 admission: Arc<dyn Admission>, 18 scope: &crate::scope::Scope, 19 ) -> Result<Arc<dyn Socket>, Error> { 20 poll_fn(|context| { 21 Poll::Ready( 22 if admission.admitted_read(context) && admission.admitted_write(context) { 23 Ok(()) 24 } else { 25 Err(Error::Policy) 26 }, 27 ) 28 }) 29 .await?; 30 let shared = Arc::new(Shared::new(admission, limit.get())); 31 scope.register(&shared)?; 32 let (sender, receiver) = oneshot::channel(); 33 let mut cancellation = CancelConnect(Some(shared.clone())); 34 start_owner( 35 endpoint.to_owned(), 36 Instant::now() + timeout, 37 shared, 38 sender, 39 ); 40 let result = receiver.await.unwrap_or(Err(Error::Closed)); 41 if result.is_ok() { 42 cancellation.0.take(); 43 } 44 result 45 } 46 47 struct CancelConnect(Option<Arc<Shared>>); 48 impl Drop for CancelConnect { 49 fn drop(&mut self) { 50 if let Some(shared) = &self.0 { 51 shared.stop(); 52 } 53 } 54 } 55 56 // This synchronous handoff is the only place the Send future touches the local 57 // executor. The spawned future, DOM values and callbacks never leave it. 58 fn start_owner( 59 endpoint: String, 60 deadline: Instant, 61 shared: Arc<Shared>, 62 ready: oneshot::Sender<Result<Arc<dyn Socket>, Error>>, 63 ) { 64 wasm_bindgen_futures::spawn_local(async move { 65 let result = poll_fn(|context| { 66 // The local owner may start after the original caller yielded. 67 // Recheck the original grant before constructing the DOM socket. 68 if !shared.admission.admitted_read(context) || !shared.admission.admitted_write(context) 69 { 70 return Poll::Ready(Err(Error::Policy)); 71 } 72 Poll::Ready(Owner::open(&endpoint, shared.clone(), deadline)) 73 }) 74 .await; 75 let mut owner = match result { 76 Ok(owner) => owner, 77 Err(error) => { 78 shared.fail(error); 79 shared.finish(); 80 let _ = ready.send(Err(error)); 81 return; 82 } 83 }; 84 let opening = poll_fn(|context| { 85 shared.actor.register(context.waker()); 86 if !shared.admission.admitted_read(context) || !shared.admission.admitted_write(context) 87 { 88 return Poll::Ready(Err(Error::Policy)); 89 } 90 let state = shared.lock()?; 91 Poll::Ready(match state.status { 92 Status::Open if !state.stopping => Ok(()), 93 Status::Failed(error) => Err(error), 94 Status::Ended => Err(Error::Closed), 95 _ if state.stopping => Err(Error::Closed), 96 _ => return Poll::Pending, 97 }) 98 }); 99 let opened = match select(pin!(opening), pin!(sleep_until(deadline))).await { 100 Either::Left((result, _)) => result, 101 Either::Right(_) => Err(Error::Timeout), 102 }; 103 if let Err(error) = opened { 104 shared.fail(error); 105 let _ = ready.send(Err(error)); 106 return; 107 } 108 let socket: Arc<dyn Socket> = Arc::new(BrowserSocket { 109 shared: shared.clone(), 110 sending: Mutex::new(()), 111 receiving: Mutex::new(()), 112 closing: Mutex::new(()), 113 }); 114 if ready.send(Ok(socket)).is_err() { 115 return; 116 } 117 owner.drive().await; 118 }); 119 } 120 121 async fn sleep_until(deadline: Instant) { 122 loop { 123 let remaining = deadline.saturating_duration_since(Instant::now()); 124 if remaining.is_zero() { 125 return; 126 } 127 let millis = remaining 128 .as_nanos() 129 .div_ceil(1_000_000) 130 .min(i32::MAX as u128) as u64; 131 async_utility::time::sleep(Duration::from_millis(millis)).await; 132 } 133 } 134 135 struct BrowserSocket { 136 shared: Arc<Shared>, 137 sending: Mutex<()>, 138 receiving: Mutex<()>, 139 closing: Mutex<()>, 140 } 141 142 impl Drop for BrowserSocket { 143 fn drop(&mut self) { 144 self.shared.stop(); 145 } 146 } 147 148 impl Socket for BrowserSocket { 149 fn send(&self, frame: Frame) -> IoFuture<'_, Result<(), Error>> { 150 Box::pin(async move { 151 let bytes = payload_len(&frame)?; 152 if bytes > self.shared.limit { 153 return Err(Error::Protocol); 154 } 155 let _guard = self.sending.lock().await; 156 let (sender, receiver) = oneshot::channel(); 157 { 158 let mut state = self.shared.lock()?; 159 if state.stopping || state.status != Status::Open { 160 return Err(Error::Closed); 161 } 162 // Cancellation of a send observer does not erase admitted I/O. 163 if state.outgoing.is_some() { 164 return Err(Error::Policy); 165 } 166 state.outgoing = Some(SendRequest { 167 frame, 168 result: sender, 169 }); 170 } 171 self.shared.actor.wake(); 172 receiver.await.unwrap_or(Err(Error::Closed)) 173 }) 174 } 175 176 fn receive(&self) -> IoFuture<'_, Result<Option<Frame>, Error>> { 177 Box::pin(async move { 178 let _guard = self.receiving.lock().await; 179 poll_fn(|context| { 180 self.shared.reader.register(context.waker()); 181 if !self.shared.admission.admitted_read(context) { 182 self.shared.fail(Error::Policy); 183 return Poll::Ready(Err(Error::Policy)); 184 } 185 if let Some(frame) = self.shared.pop()? { 186 return Poll::Ready(Ok(Some(frame))); 187 } 188 let state = self.shared.lock()?; 189 if state.finished || state.stopping || state.status == Status::Ended { 190 Poll::Ready(Ok(None)) 191 } else { 192 Poll::Pending 193 } 194 }) 195 .await 196 }) 197 } 198 199 fn close(&self) -> IoFuture<'_, Result<(), Error>> { 200 Box::pin(async move { 201 let _guard = self.closing.lock().await; 202 self.shared.stop(); 203 poll_fn(|context| { 204 self.shared.closer.register(context.waker()); 205 let finished = self.shared.lock()?.finished; 206 if finished { 207 self.shared.closer.take(); 208 Poll::Ready(Ok(())) 209 } else { 210 Poll::Pending 211 } 212 }) 213 .await 214 }) 215 } 216 } 217 218 struct Owner { 219 socket: WebSocket, 220 shared: Arc<Shared>, 221 _open: Closure<dyn FnMut(Event)>, 222 _message: Closure<dyn FnMut(MessageEvent)>, 223 _error: Closure<dyn FnMut(Event)>, 224 _close: Closure<dyn FnMut(Event)>, 225 } 226 227 impl Owner { 228 fn open(endpoint: &str, shared: Arc<Shared>, deadline: Instant) -> Result<Self, Error> { 229 if shared.lock()?.stopping { 230 return Err(Error::Closed); 231 } 232 if Instant::now() >= deadline { 233 return Err(Error::Timeout); 234 } 235 let socket = WebSocket::new(endpoint).map_err(|_| Error::Unavailable)?; 236 socket.set_binary_type(BinaryType::Arraybuffer); 237 let state = shared.clone(); 238 let open = Closure::new(move |_: Event| { 239 if let Ok(mut inner) = state.lock() 240 && inner.status == Status::Connecting 241 && !inner.stopping 242 { 243 inner.status = Status::Open; 244 } 245 state.wake(); 246 }); 247 let state = shared.clone(); 248 let message = Closure::new(move |event: MessageEvent| { 249 let frame = decode_message(event, state.limit).and_then(|frame| state.push(frame)); 250 if let Err(error) = frame { 251 state.fail(error); 252 } 253 }); 254 let state = shared.clone(); 255 let error = Closure::new(move |_: Event| state.fail(Error::Unavailable)); 256 let state = shared.clone(); 257 let close = Closure::new(move |_: Event| { 258 if let Ok(mut inner) = state.lock() 259 && !matches!(inner.status, Status::Failed(_)) 260 { 261 inner.status = Status::Ended; 262 } 263 state.wake(); 264 }); 265 socket.set_onopen(Some(open.as_ref().unchecked_ref())); 266 socket.set_onmessage(Some(message.as_ref().unchecked_ref())); 267 socket.set_onerror(Some(error.as_ref().unchecked_ref())); 268 socket.set_onclose(Some(close.as_ref().unchecked_ref())); 269 Ok(Self { 270 socket, 271 shared, 272 _open: open, 273 _message: message, 274 _error: error, 275 _close: close, 276 }) 277 } 278 279 async fn drive(&mut self) { 280 poll_fn(|context| { 281 self.shared.actor.register(context.waker()); 282 if !self.shared.admission.admitted_read(context) 283 || !self.shared.admission.admitted_write(context) 284 { 285 self.shared.fail(Error::Policy); 286 } 287 let request = { 288 let mut state = match self.shared.lock() { 289 Ok(state) => state, 290 Err(_) => return Poll::Ready(()), 291 }; 292 if state.stopping || state.status != Status::Open { 293 return Poll::Ready(()); 294 } 295 state.outgoing.take() 296 }; 297 if let Some(request) = request { 298 let result = self.send(request.frame); 299 if let Err(error) = result { 300 self.shared.fail(error); 301 } 302 let _ = request.result.send(result); 303 if result.is_err() { 304 return Poll::Ready(()); 305 } 306 } 307 Poll::Pending 308 }) 309 .await; 310 } 311 312 fn send(&self, frame: Frame) -> Result<(), Error> { 313 let bytes = payload_len(&frame)?; 314 if bytes > self.shared.limit { 315 return Err(Error::Protocol); 316 } 317 if u64::from(self.socket.buffered_amount()) + bytes as u64 > MAX_QUEUE_BYTES as u64 { 318 return Err(Error::Policy); 319 } 320 match frame { 321 Frame::Text(text) => self.socket.send_with_str(&text), 322 Frame::Binary(bytes) => self.socket.send_with_u8_array(&bytes), 323 _ => return Err(Error::Unsupported), 324 } 325 .map_err(|_| Error::Unavailable) 326 } 327 } 328 329 impl Drop for Owner { 330 fn drop(&mut self) { 331 self.socket.set_onopen(None); 332 self.socket.set_onmessage(None); 333 self.socket.set_onerror(None); 334 self.socket.set_onclose(None); 335 let _ = self.socket.close(); 336 self.shared.finish(); 337 } 338 } 339 340 fn decode_message(event: MessageEvent, limit: usize) -> Result<Frame, Error> { 341 let data = event.data(); 342 if data.is_string() { 343 let value: js_sys::JsString = data.unchecked_into(); 344 if value.length() as usize > limit { 345 return Err(Error::Protocol); 346 } 347 let text: String = value.into(); 348 if text.len() > limit { 349 return Err(Error::Protocol); 350 } 351 Ok(Frame::Text(text)) 352 } else if data.is_instance_of::<js_sys::ArrayBuffer>() { 353 let buffer: js_sys::ArrayBuffer = data.unchecked_into(); 354 if buffer.byte_length() as usize > limit { 355 return Err(Error::Protocol); 356 } 357 Ok(Frame::Binary(js_sys::Uint8Array::new(&buffer).to_vec())) 358 } else { 359 Err(Error::Protocol) 360 } 361 }