use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use async_trait::async_trait;
use crate::error::StoreError;
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum WriteOp {
Put {
key: String,
value: Vec<u8>,
},
Delete {
key: String,
},
}
pub trait TransactionReader {
fn get(&self, key: &str) -> Result<Option<Vec<u8>>, StoreError>;
fn list(&self, prefix: &str) -> Result<Vec<String>, StoreError>;
}
#[cfg(not(target_arch = "wasm32"))]
pub type TransactFn = Box<dyn FnOnce(&dyn TransactionReader) -> Vec<WriteOp> + Send>;
#[cfg(target_arch = "wasm32")]
pub type TransactFn = Box<dyn FnOnce(&dyn TransactionReader) -> Vec<WriteOp>>;
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
pub trait Backend {
async fn get(&self, key: &str) -> Result<Option<Vec<u8>>, StoreError>;
async fn put(&self, key: &str, bytes: &[u8]) -> Result<(), StoreError>;
async fn delete(&self, key: &str) -> Result<(), StoreError>;
async fn list(&self, prefix: &str) -> Result<Vec<String>, StoreError>;
async fn scan(&self, start: &str, end: &str) -> Result<Vec<String>, StoreError>;
async fn apply(&self, ops: &[WriteOp]) -> Result<(), StoreError>;
async fn transact(&self, f: TransactFn) -> Result<(), StoreError> {
let _ = f;
Err(StoreError::NotTransactional)
}
}
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
impl<B: Backend + Sync + ?Sized> Backend for Box<B> {
async fn get(&self, key: &str) -> Result<Option<Vec<u8>>, StoreError> {
(**self).get(key).await
}
async fn put(&self, key: &str, bytes: &[u8]) -> Result<(), StoreError> {
(**self).put(key, bytes).await
}
async fn delete(&self, key: &str) -> Result<(), StoreError> {
(**self).delete(key).await
}
async fn list(&self, prefix: &str) -> Result<Vec<String>, StoreError> {
(**self).list(prefix).await
}
async fn scan(&self, start: &str, end: &str) -> Result<Vec<String>, StoreError> {
(**self).scan(start, end).await
}
async fn apply(&self, ops: &[WriteOp]) -> Result<(), StoreError> {
(**self).apply(ops).await
}
async fn transact(&self, f: TransactFn) -> Result<(), StoreError> {
(**self).transact(f).await
}
}
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
impl<B: Backend + Sync + ?Sized> Backend for &B {
async fn get(&self, key: &str) -> Result<Option<Vec<u8>>, StoreError> {
(**self).get(key).await
}
async fn put(&self, key: &str, bytes: &[u8]) -> Result<(), StoreError> {
(**self).put(key, bytes).await
}
async fn delete(&self, key: &str) -> Result<(), StoreError> {
(**self).delete(key).await
}
async fn list(&self, prefix: &str) -> Result<Vec<String>, StoreError> {
(**self).list(prefix).await
}
async fn scan(&self, start: &str, end: &str) -> Result<Vec<String>, StoreError> {
(**self).scan(start, end).await
}
async fn apply(&self, ops: &[WriteOp]) -> Result<(), StoreError> {
(**self).apply(ops).await
}
async fn transact(&self, f: TransactFn) -> Result<(), StoreError> {
(**self).transact(f).await
}
}
#[derive(Clone, Default)]
pub struct MemoryBackend {
map: Arc<Mutex<HashMap<String, Vec<u8>>>>,
}
impl MemoryBackend {
pub fn new() -> Self {
Self::default()
}
pub fn len(&self) -> usize {
self.map.lock().unwrap().len()
}
pub fn is_empty(&self) -> bool {
self.map.lock().unwrap().is_empty()
}
}
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
impl Backend for MemoryBackend {
async fn get(&self, key: &str) -> Result<Option<Vec<u8>>, StoreError> {
Ok(self.map.lock().unwrap().get(key).cloned())
}
async fn put(&self, key: &str, bytes: &[u8]) -> Result<(), StoreError> {
self.map
.lock()
.unwrap()
.insert(key.to_string(), bytes.to_vec());
Ok(())
}
async fn delete(&self, key: &str) -> Result<(), StoreError> {
self.map.lock().unwrap().remove(key);
Ok(())
}
async fn list(&self, prefix: &str) -> Result<Vec<String>, StoreError> {
Ok(self
.map
.lock()
.unwrap()
.keys()
.filter(|k| k.starts_with(prefix))
.cloned()
.collect())
}
async fn scan(&self, start: &str, end: &str) -> Result<Vec<String>, StoreError> {
let mut keys: Vec<String> = self
.map
.lock()
.unwrap()
.keys()
.filter(|k| k.as_str() >= start && k.as_str() < end)
.cloned()
.collect();
keys.sort();
Ok(keys)
}
async fn apply(&self, ops: &[WriteOp]) -> Result<(), StoreError> {
let mut map = self.map.lock().unwrap();
for op in ops {
match op {
WriteOp::Put { key, value } => {
map.insert(key.clone(), value.clone());
},
WriteOp::Delete { key } => {
map.remove(key);
},
}
}
Ok(())
}
async fn transact(&self, f: TransactFn) -> Result<(), StoreError> {
struct MapReader<'a>(&'a HashMap<String, Vec<u8>>);
impl TransactionReader for MapReader<'_> {
fn get(&self, key: &str) -> Result<Option<Vec<u8>>, StoreError> {
Ok(self.0.get(key).cloned())
}
fn list(&self, prefix: &str) -> Result<Vec<String>, StoreError> {
Ok(self
.0
.keys()
.filter(|k| k.starts_with(prefix))
.cloned()
.collect())
}
}
let mut map = self.map.lock().unwrap();
let ops = f(&MapReader(&map));
for op in ops {
match op {
WriteOp::Put { key, value } => {
map.insert(key, value);
},
WriteOp::Delete { key } => {
map.remove(&key);
},
}
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn backend_futures_are_send_on_native() {
fn assert_send<T: Send>(_: T) {}
let b = MemoryBackend::new();
assert_send(b.get("k"));
assert_send(b.put("k", b"v"));
assert_send(b.apply(&[]));
}
#[test]
fn a_borrowed_backend_shares_the_keyspace() {
pollster::block_on(async {
let owned = MemoryBackend::new();
let borrowed: &MemoryBackend = &owned;
borrowed.put("k", b"v").await.unwrap();
assert_eq!(owned.get("k").await.unwrap(), Some(b"v".to_vec()));
assert_eq!(borrowed.list("").await.unwrap(), vec!["k".to_string()]);
});
}
fn seed() -> MemoryBackend {
let b = MemoryBackend::new();
pollster::block_on(async {
for (k, v) in [
("log/a/0/0000000000000002", "two"),
("log/a/0/0000000000000000", "zero"),
("log/a/0/0000000000000001", "one"),
("log/b/0/0000000000000000", "other-log"),
] {
b.put(k, v.as_bytes()).await.unwrap();
}
});
b
}
#[test]
fn scan_returns_the_range_in_ascending_order() {
pollster::block_on(async {
let b = seed();
let keys = b
.scan("log/a/0/0000000000000000", "log/a/0/0000000000000003")
.await
.unwrap();
assert_eq!(
keys,
vec![
"log/a/0/0000000000000000".to_string(),
"log/a/0/0000000000000001".to_string(),
"log/a/0/0000000000000002".to_string(),
]
);
let one = b
.scan("log/a/0/0000000000000001", "log/a/0/0000000000000002")
.await
.unwrap();
assert_eq!(one, vec!["log/a/0/0000000000000001".to_string()]);
});
}
#[test]
fn apply_lands_the_whole_batch() {
pollster::block_on(async {
let b = MemoryBackend::new();
b.put("keep", b"v").await.unwrap();
b.put("drop", b"v").await.unwrap();
b.apply(&[
WriteOp::Put {
key: "op/h".into(),
value: b"header".to_vec(),
},
WriteOp::Put {
key: "op/h/payload".into(),
value: b"body".to_vec(),
},
WriteOp::Delete { key: "drop".into() },
])
.await
.unwrap();
assert_eq!(b.get("op/h").await.unwrap(), Some(b"header".to_vec()));
assert_eq!(b.get("op/h/payload").await.unwrap(), Some(b"body".to_vec()));
assert_eq!(b.get("drop").await.unwrap(), None);
assert_eq!(b.get("keep").await.unwrap(), Some(b"v".to_vec()));
});
}
#[test]
fn apply_takes_the_whole_batch_in_one_call() {
pollster::block_on(async {
let b = MemoryBackend::new();
b.apply(&[]).await.unwrap();
assert!(b.is_empty(), "empty batch writes nothing");
b.apply(&[WriteOp::Put {
key: "k".into(),
value: b"v".to_vec(),
}])
.await
.unwrap();
assert_eq!(b.len(), 1);
});
}
#[test]
fn a_backend_chosen_at_runtime_is_still_a_backend() {
pollster::block_on(async {
fn store<B: Backend>(backend: B) -> B {
backend
}
let chosen: Box<dyn Backend + Send + Sync> = Box::new(MemoryBackend::new());
let backend = store(chosen);
backend.put("k", b"v").await.unwrap();
assert_eq!(backend.get("k").await.unwrap(), Some(b"v".to_vec()));
});
}
}