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 }