lib

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

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 }