lib

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

state.rs (4834B)


      1 //! Bounded owned data only. No JavaScript values cross this boundary.
      2 
      3 use futures::{channel::oneshot, task::AtomicWaker};
      4 use radroots_transport::host::websocket::{Admission, Error, Frame};
      5 use std::{
      6     collections::VecDeque,
      7     sync::{Arc, Mutex, MutexGuard},
      8 };
      9 
     10 pub(crate) const MAX_MESSAGE: usize = 512 * 1024;
     11 pub(crate) const MAX_QUEUE_BYTES: usize = 4 * 1024 * 1024;
     12 pub(crate) const MAX_QUEUE_MESSAGES: usize = 256;
     13 
     14 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
     15 pub(crate) enum Status {
     16     Connecting,
     17     Open,
     18     Ended,
     19     Failed(Error),
     20 }
     21 
     22 pub(crate) struct SendRequest {
     23     pub(crate) frame: Frame,
     24     pub(crate) result: oneshot::Sender<Result<(), Error>>,
     25 }
     26 
     27 pub(crate) struct State {
     28     pub(crate) status: Status,
     29     pub(crate) stopping: bool,
     30     pub(crate) finished: bool,
     31     pub(crate) outgoing: Option<SendRequest>,
     32     incoming: VecDeque<Frame>,
     33     bytes: usize,
     34 }
     35 
     36 impl State {
     37     fn check_enqueue(&self, bytes: usize, limit: usize) -> Result<(), Error> {
     38         if self.stopping || self.status != Status::Open {
     39             return Err(Error::Closed);
     40         }
     41         if bytes > limit
     42             || self.incoming.len() >= MAX_QUEUE_MESSAGES
     43             || bytes > MAX_QUEUE_BYTES.saturating_sub(self.bytes)
     44         {
     45             return Err(Error::Policy);
     46         }
     47         Ok(())
     48     }
     49 }
     50 
     51 pub(crate) struct Shared {
     52     state: Mutex<State>,
     53     pub(crate) admission: Arc<dyn Admission>,
     54     pub(crate) limit: usize,
     55     pub(crate) actor: AtomicWaker,
     56     pub(crate) reader: AtomicWaker,
     57     pub(crate) closer: AtomicWaker,
     58     pub(crate) scope_closer: AtomicWaker,
     59 }
     60 
     61 impl Shared {
     62     pub(crate) fn new(admission: Arc<dyn Admission>, limit: usize) -> Self {
     63         Self {
     64             state: Mutex::new(State {
     65                 status: Status::Connecting,
     66                 stopping: false,
     67                 finished: false,
     68                 outgoing: None,
     69                 incoming: VecDeque::new(),
     70                 bytes: 0,
     71             }),
     72             admission,
     73             limit: limit.min(MAX_MESSAGE),
     74             actor: AtomicWaker::new(),
     75             reader: AtomicWaker::new(),
     76             closer: AtomicWaker::new(),
     77             scope_closer: AtomicWaker::new(),
     78         }
     79     }
     80 
     81     pub(crate) fn lock(&self) -> Result<MutexGuard<'_, State>, Error> {
     82         self.state.lock().map_err(|_| Error::Closed)
     83     }
     84 
     85     pub(crate) fn wake(&self) {
     86         self.actor.wake();
     87         self.reader.wake();
     88         self.closer.wake();
     89         self.scope_closer.wake();
     90     }
     91 
     92     pub(crate) fn stop(&self) {
     93         if let Ok(mut state) = self.lock() {
     94             state.stopping = true;
     95         }
     96         self.wake();
     97     }
     98 
     99     pub(crate) fn fail(&self, error: Error) {
    100         if let Ok(mut state) = self.lock() {
    101             // The first refusal remains authoritative through later callbacks.
    102             if !matches!(state.status, Status::Failed(_)) {
    103                 state.status = Status::Failed(error);
    104             }
    105             state.incoming.clear();
    106             state.bytes = 0;
    107         }
    108         self.wake();
    109     }
    110 
    111     pub(crate) fn push(&self, frame: Frame) -> Result<(), Error> {
    112         let bytes = payload_len(&frame)?;
    113         self.lock()?.check_enqueue(bytes, self.limit)?;
    114         // Admission may wake or cancel an observer. Call it without our lock,
    115         // then revalidate closure and queue credit before exposing the frame.
    116         if !self.admission.charge(bytes, 1, 1) {
    117             return Err(Error::Policy);
    118         }
    119         let mut state = self.lock()?;
    120         state.check_enqueue(bytes, self.limit)?;
    121         state.bytes += bytes;
    122         state.incoming.push_back(frame);
    123         drop(state);
    124         self.wake();
    125         Ok(())
    126     }
    127 
    128     pub(crate) fn pop(&self) -> Result<Option<Frame>, Error> {
    129         let mut state = self.lock()?;
    130         if let Status::Failed(error) = state.status {
    131             return Err(error);
    132         }
    133         let frame = state.incoming.pop_front();
    134         if let Some(frame) = &frame {
    135             state.bytes -= payload_len(frame)?;
    136         }
    137         Ok(frame)
    138     }
    139 
    140     pub(crate) fn finish(&self) {
    141         let outgoing = if let Ok(mut state) = self.lock() {
    142             state.finished = true;
    143             if !matches!(state.status, Status::Failed(_)) {
    144                 state.status = Status::Ended;
    145             }
    146             state.outgoing.take()
    147         } else {
    148             None
    149         };
    150         if let Some(request) = outgoing {
    151             let _ = request.result.send(Err(Error::Closed));
    152         }
    153         self.wake();
    154     }
    155 }
    156 
    157 pub(crate) fn payload_len(frame: &Frame) -> Result<usize, Error> {
    158     match frame {
    159         Frame::Text(text) => Ok(text.len()),
    160         Frame::Binary(bytes) => Ok(bytes.len()),
    161         _ => Err(Error::Unsupported),
    162     }
    163 }
    164 
    165 #[cfg(test)]
    166 #[path = "state_tests.rs"]
    167 pub(crate) mod tests;