lib.rs (4180B)
1 use futures::FutureExt; 2 use radroots_storage::event::SourceGeneration; 3 use radroots_storage_indexeddb::{ 4 Batch, Database, Error, Mutation, Namespace, OpenMode, RecordKey, 5 }; 6 use wasm_bindgen::prelude::*; 7 8 mod protected; 9 pub use protected::protected_round_trip; 10 mod persistent; 11 pub use persistent::Persistent; 12 mod workspace; 13 pub use workspace::{ObtainedEnvelope, ObtainedObservation, ObtainedSeal, WorkspaceFixture}; 14 mod snapshot; 15 pub use snapshot::Frozen; 16 17 fn failure(error: Error) -> JsValue { 18 JsValue::from_str(error.code()) 19 } 20 fn key(n: u8) -> RecordKey { 21 RecordKey::new([n; 32]) 22 } 23 fn batch(n: u8, old: Option<Vec<u8>>, new: Option<Vec<u8>>) -> Result<Batch, JsValue> { 24 Batch::new(vec![Mutation::new(key(n), old, new).map_err(failure)?]).map_err(failure) 25 } 26 #[wasm_bindgen] 27 pub struct Fixture { 28 db: Database, 29 } 30 #[wasm_bindgen] 31 impl Fixture { 32 #[wasm_bindgen(js_name = open)] 33 pub async fn open(n: u8, create: bool) -> Result<Fixture, JsValue> { 34 let namespace = Namespace::new( 35 SourceGeneration::new([n; 32]).map_err(|_| JsValue::from_str("invalid_generation"))?, 36 ); 37 Ok(Self { 38 db: Database::open( 39 namespace, 40 if create { 41 OpenMode::CreateNew 42 } else { 43 OpenMode::Existing 44 }, 45 ) 46 .await 47 .map_err(failure)?, 48 }) 49 } 50 pub async fn write( 51 &self, 52 n: u8, 53 old: Option<Vec<u8>>, 54 new: Option<Vec<u8>>, 55 ) -> Result<usize, JsValue> { 56 Ok(self 57 .db 58 .compare_exchange(batch(n, old, new)?) 59 .await 60 .map_err(failure)? 61 .records()) 62 } 63 pub async fn read(&self, n: u8) -> Result<JsValue, JsValue> { 64 Ok(self 65 .db 66 .get(key(n)) 67 .await 68 .map_err(failure)? 69 .map(|bytes| js_sys::Uint8Array::from(bytes.as_slice()).into()) 70 .unwrap_or(JsValue::UNDEFINED)) 71 } 72 pub async fn atomic_pair(&self, second_expected: u8) -> Result<usize, JsValue> { 73 let entries = vec![ 74 Mutation::new(key(1), Some(vec![1]), Some(vec![3])).map_err(failure)?, 75 Mutation::new(key(2), Some(vec![second_expected]), Some(vec![4])).map_err(failure)?, 76 ]; 77 Ok(self 78 .db 79 .compare_exchange(Batch::new(entries).map_err(failure)?) 80 .await 81 .map_err(failure)? 82 .records()) 83 } 84 pub async fn refused_pair(&self) -> Result<(), JsValue> { 85 let n = std::cell::Cell::new(0usize); 86 let entries = vec![ 87 Mutation::new(key(1), Some(vec![1]), Some(vec![3])).map_err(failure)?, 88 Mutation::new(key(2), Some(vec![2]), Some(vec![4])).map_err(failure)?, 89 ]; 90 self.db 91 .compare_exchange_checked(Batch::new(entries).map_err(failure)?, move || { 92 n.set(n.get() + 1); 93 n.get() == 1 94 }) 95 .await 96 .map(|_| ()) 97 .map_err(failure) 98 } 99 pub fn abandon_write(&self, n: u8) -> Result<(), JsValue> { 100 let result = self 101 .db 102 .compare_exchange(batch(n, None, Some(vec![n]))?) 103 .now_or_never(); 104 if result.is_some() { 105 return Err(JsValue::from_str("unexpected_immediate_completion")); 106 } 107 Ok(()) 108 } 109 pub fn abandon_reads(&self, count: usize) -> Result<usize, JsValue> { 110 for index in 0..count { 111 if let Some(result) = self.db.get(key(1)).now_or_never() { 112 return match result { 113 Err(Error::Capacity) => Ok(index), 114 _ => Err(JsValue::from_str("unexpected_admission_result")), 115 }; 116 } 117 } 118 Ok(count) 119 } 120 pub fn abandon_close(&self) -> Result<(), JsValue> { 121 if self.db.close().now_or_never().is_some() { 122 return Err(JsValue::from_str("unexpected_immediate_close")); 123 } 124 Ok(()) 125 } 126 pub async fn close(&self) -> Result<(), JsValue> { 127 self.db.close().await.map_err(failure) 128 } 129 }