lib

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

lease.rs (4185B)


      1 //! Origin-scoped Web Lock, held until the actual database owner is finished.
      2 use futures::channel::oneshot;
      3 use js_sys::{Function, Object, Promise, Reflect};
      4 use radroots_storage::workspace::WorkspaceError;
      5 use std::{
      6     cell::{Cell, RefCell},
      7     rc::Rc,
      8 };
      9 use wasm_bindgen::{JsCast, JsValue, closure::Closure};
     10 use wasm_bindgen_futures::{JsFuture, future_to_promise, spawn_local};
     11 
     12 pub(super) struct Lease {
     13     release: Option<oneshot::Sender<()>>,
     14     finished: Option<oneshot::Receiver<Result<(), WorkspaceError>>>,
     15     active: Rc<Cell<bool>>,
     16 }
     17 impl Lease {
     18     pub async fn acquire(name: &str) -> Result<Self, WorkspaceError> {
     19         let unavailable = |_| WorkspaceError::Unavailable;
     20         let navigator =
     21             Reflect::get(&js_sys::global(), &"navigator".into()).map_err(unavailable)?;
     22         let locks = Reflect::get(&navigator, &"locks".into()).map_err(unavailable)?;
     23         let request = Reflect::get(&locks, &"request".into())
     24             .map_err(unavailable)?
     25             .dyn_into::<Function>()
     26             .map_err(unavailable)?;
     27         let options = Object::new();
     28         Reflect::set(&options, &"mode".into(), &"exclusive".into()).map_err(unavailable)?;
     29         Reflect::set(&options, &"ifAvailable".into(), &JsValue::TRUE).map_err(unavailable)?;
     30         let (acquired, observe) = oneshot::channel();
     31         let acquired = Rc::new(RefCell::new(Some(acquired)));
     32         let (release, released) = oneshot::channel();
     33         let mut released = Some(released);
     34         let signal = acquired.clone();
     35         let active = Rc::new(Cell::new(false));
     36         let granted = active.clone();
     37         let callback = Closure::<dyn FnMut(JsValue) -> Promise>::new(move |lock: JsValue| {
     38             if lock.is_null() || lock.is_undefined() {
     39                 if let Some(send) = signal.borrow_mut().take() {
     40                     let _ = send.send(Err(WorkspaceError::WriterActive));
     41                 }
     42                 return Promise::resolve(&JsValue::UNDEFINED);
     43             }
     44             granted.set(true);
     45             if let Some(send) = signal.borrow_mut().take() {
     46                 let _ = send.send(Ok(()));
     47             }
     48             let wait = released.take();
     49             future_to_promise(async move {
     50                 if let Some(wait) = wait {
     51                     let _ = wait.await;
     52                 }
     53                 Ok(JsValue::UNDEFINED)
     54             })
     55         });
     56         // The stable Web Locks API is called locally; no global unstable
     57         // web-sys compiler flag or public JavaScript object is required.
     58         let promise = request
     59             .call3(
     60                 &locks,
     61                 &JsValue::from_str(name),
     62                 &options,
     63                 callback.as_ref().unchecked_ref(),
     64             )
     65             .map_err(unavailable)?
     66             .dyn_into::<Promise>()
     67             .map_err(unavailable)?;
     68         let (done, finished) = oneshot::channel();
     69         let lifetime = active.clone();
     70         spawn_local(async move {
     71             let result = JsFuture::from(promise)
     72                 .await
     73                 .map(|_| ())
     74                 .map_err(unavailable);
     75             lifetime.set(false);
     76             if let Some(send) = acquired.borrow_mut().take() {
     77                 let _ = send.send(Err(WorkspaceError::Unavailable));
     78             }
     79             let _ = done.send(result);
     80             drop(callback);
     81         });
     82         let lease = Self {
     83             release: Some(release),
     84             finished: Some(finished),
     85             active,
     86         };
     87         observe.await.map_err(|_| WorkspaceError::Unavailable)??;
     88         Ok(lease)
     89     }
     90     pub fn active(&self) -> Rc<Cell<bool>> {
     91         self.active.clone()
     92     }
     93     pub async fn release(mut self) -> Result<(), WorkspaceError> {
     94         if let Some(send) = self.release.take() {
     95             let _ = send.send(());
     96         }
     97         match self.finished.take() {
     98             Some(done) => done.await.map_err(|_| WorkspaceError::Unavailable)?,
     99             None => Err(WorkspaceError::Unavailable),
    100         }
    101     }
    102 }
    103 impl Drop for Lease {
    104     fn drop(&mut self) {
    105         if let Some(send) = self.release.take() {
    106             let _ = send.send(());
    107         }
    108     }
    109 }