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;