use std::path::Path;
use std::sync::Arc;
use async_trait::async_trait;
use ::redb::{Database, ReadableTable, TableDefinition};
use crate::backend::{Backend, TransactFn, TransactionReader, WriteOp};
use crate::error::StoreError;
const TABLE: TableDefinition<&str, &[u8]> = TableDefinition::new("muniment");
fn backend(err: impl std::fmt::Display) -> StoreError {
StoreError::Backend(err.to_string())
}
#[derive(Clone)]
pub struct RedbBackend {
db: Arc<Database>,
}
impl RedbBackend {
pub fn open(path: impl AsRef<Path>) -> Result<Self, StoreError> {
let db = Database::create(path).map_err(backend)?;
let txn = db.begin_write().map_err(backend)?;
txn.open_table(TABLE).map_err(backend)?;
txn.commit().map_err(backend)?;
Ok(Self { db: Arc::new(db) })
}
}
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
impl Backend for RedbBackend {
async fn get(&self, key: &str) -> Result<Option<Vec<u8>>, StoreError> {
let read = self.db.begin_read().map_err(backend)?;
let table = read.open_table(TABLE).map_err(backend)?;
match table.get(key).map_err(backend)? {
Some(value) => Ok(Some(value.value().to_vec())),
None => Ok(None),
}
}
async fn put(&self, key: &str, bytes: &[u8]) -> Result<(), StoreError> {
let txn = self.db.begin_write().map_err(backend)?;
{
let mut table = txn.open_table(TABLE).map_err(backend)?;
table.insert(key, bytes).map_err(backend)?;
}
txn.commit().map_err(backend)?;
Ok(())
}
async fn delete(&self, key: &str) -> Result<(), StoreError> {
let txn = self.db.begin_write().map_err(backend)?;
{
let mut table = txn.open_table(TABLE).map_err(backend)?;
table.remove(key).map_err(backend)?;
}
txn.commit().map_err(backend)?;
Ok(())
}
async fn list(&self, prefix: &str) -> Result<Vec<String>, StoreError> {
let read = self.db.begin_read().map_err(backend)?;
let table = read.open_table(TABLE).map_err(backend)?;
let mut keys = Vec::new();
for entry in table.range(prefix..).map_err(backend)? {
let (key, _value) = entry.map_err(backend)?;
let key = key.value();
if !key.starts_with(prefix) {
break;
}
keys.push(key.to_string());
}
Ok(keys)
}
async fn scan(&self, start: &str, end: &str) -> Result<Vec<String>, StoreError> {
let read = self.db.begin_read().map_err(backend)?;
let table = read.open_table(TABLE).map_err(backend)?;
let mut keys = Vec::new();
for entry in table.range(start..end).map_err(backend)? {
let (key, _value) = entry.map_err(backend)?;
keys.push(key.value().to_string());
}
Ok(keys)
}
async fn apply(&self, ops: &[WriteOp]) -> Result<(), StoreError> {
let txn = self.db.begin_write().map_err(backend)?;
{
let mut table = txn.open_table(TABLE).map_err(backend)?;
for op in ops {
match op {
WriteOp::Put { key, value } => {
table
.insert(key.as_str(), value.as_slice())
.map_err(backend)?;
},
WriteOp::Delete { key } => {
table.remove(key.as_str()).map_err(backend)?;
},
}
}
}
txn.commit().map_err(backend)?;
Ok(())
}
async fn transact(&self, f: TransactFn) -> Result<(), StoreError> {
let txn = self.db.begin_write().map_err(backend)?;
{
let mut table = txn.open_table(TABLE).map_err(backend)?;
let ops = {
struct Reader<'r, 'txn>(&'r ::redb::Table<'txn, &'static str, &'static [u8]>);
impl TransactionReader for Reader<'_, '_> {
fn get(&self, key: &str) -> Result<Option<Vec<u8>>, StoreError> {
match self.0.get(key).map_err(backend)? {
Some(value) => Ok(Some(value.value().to_vec())),
None => Ok(None),
}
}
fn list(&self, prefix: &str) -> Result<Vec<String>, StoreError> {
let mut keys = Vec::new();
for entry in self.0.range(prefix..).map_err(backend)? {
let (key, _value) = entry.map_err(backend)?;
let key = key.value();
if !key.starts_with(prefix) {
break;
}
keys.push(key.to_string());
}
Ok(keys)
}
}
f(&Reader(&table))
};
for op in ops {
match op {
WriteOp::Put { key, value } => {
table
.insert(key.as_str(), value.as_slice())
.map_err(backend)?;
},
WriteOp::Delete { key } => {
table.remove(key.as_str()).map_err(backend)?;
},
}
}
}
txn.commit().map_err(backend)?;
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
fn temp_backend() -> (tempfile::TempDir, RedbBackend) {
let dir = tempfile::tempdir().unwrap();
let backend = RedbBackend::open(dir.path().join("store.redb")).unwrap();
(dir, backend)
}
#[test]
fn put_get_delete_round_trip() {
pollster::block_on(async {
let (_dir, b) = temp_backend();
assert_eq!(b.get("k").await.unwrap(), None);
b.put("k", b"v").await.unwrap();
assert_eq!(b.get("k").await.unwrap(), Some(b"v".to_vec()));
b.put("k", b"v2").await.unwrap();
assert_eq!(b.get("k").await.unwrap(), Some(b"v2".to_vec()));
b.delete("k").await.unwrap();
assert_eq!(b.get("k").await.unwrap(), None);
b.delete("k").await.unwrap();
});
}
#[test]
fn list_returns_only_the_prefix() {
pollster::block_on(async {
let (_dir, b) = temp_backend();
for k in ["blob/a", "blob/b", "slot/x"] {
b.put(k, b"v").await.unwrap();
}
let mut blobs = b.list("blob/").await.unwrap();
blobs.sort();
assert_eq!(blobs, vec!["blob/a".to_string(), "blob/b".to_string()]);
assert_eq!(b.list("slot/").await.unwrap(), vec!["slot/x".to_string()]);
assert!(b.list("none/").await.unwrap().is_empty());
});
}
#[test]
fn scan_returns_the_range_in_ascending_order() {
pollster::block_on(async {
let (_dir, b) = temp_backend();
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();
}
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 (_dir, b) = temp_backend();
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 state_survives_reopen() {
pollster::block_on(async {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("store.redb");
{
let b = RedbBackend::open(&path).unwrap();
b.put("k", b"durable").await.unwrap();
}
let reopened = RedbBackend::open(&path).unwrap();
assert_eq!(reopened.get("k").await.unwrap(), Some(b"durable".to_vec()));
});
}
}