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,
},
}
#[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>;
}
#[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(())
}
}
#[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(&[]));
}
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);
});
}
}