lib

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

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 }