lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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 }