xmr-btc-swap/swap/src/storage.rs

168 lines
5.1 KiB
Rust
Raw Normal View History

2020-11-03 05:53:28 +00:00
use crate::state::Swap;
2020-11-03 04:49:00 +00:00
use anyhow::{anyhow, bail, Context, Result};
2020-11-03 05:53:28 +00:00
use serde::{de::DeserializeOwned, Serialize};
use std::path::Path;
use uuid::Uuid;
2020-11-03 05:44:04 +00:00
2020-11-03 04:26:47 +00:00
pub struct Database(sled::Db);
impl Database {
pub fn open(path: &Path) -> Result<Self> {
let db =
sled::open(path).with_context(|| format!("Could not open the DB at {:?}", path))?;
2020-11-03 04:26:47 +00:00
Ok(Database(db))
}
2020-11-03 04:26:47 +00:00
pub async fn insert_latest_state(&self, swap_id: Uuid, state: Swap) -> Result<()> {
let key = serialize(&swap_id)?;
let new_value = serialize(&state).context("Could not serialize new state value")?;
2020-11-03 04:26:47 +00:00
let old_value = self.0.get(&key)?;
2020-11-03 04:26:47 +00:00
self.0
.compare_and_swap(key, old_value, Some(new_value))
.context("Could not write in the DB")?
.context("Stored swap somehow changed, aborting saving")?;
2020-10-22 08:27:22 +00:00
// TODO: see if this can be done through sled config
2020-11-03 04:26:47 +00:00
self.0
.flush_async()
.await
.map(|_| ())
.context("Could not flush db")
}
pub fn get_state(&self, swap_id: Uuid) -> anyhow::Result<Swap> {
let key = serialize(&swap_id)?;
let encoded = self
2020-11-03 04:26:47 +00:00
.0
.get(&key)?
.ok_or_else(|| anyhow!("Swap with id {} not found in database", swap_id))?;
let state = deserialize(&encoded).context("Could not deserialize state")?;
Ok(state)
}
2020-11-03 04:49:00 +00:00
pub fn all(&self) -> Result<Vec<(Uuid, Swap)>> {
self.0
.iter()
.map(|item| match item {
Ok((key, value)) => {
let swap_id = deserialize::<Uuid>(&key);
let swap = deserialize::<Swap>(&value).context("failed to deserialize swap");
match (swap_id, swap) {
(Ok(swap_id), Ok(swap)) => Ok((swap_id, swap)),
(Ok(_), Err(err)) => Err(err),
_ => bail!("failed to deserialize swap"),
}
}
Err(err) => Err(err).context("failed to retrieve swap from DB"),
})
.collect()
}
}
pub fn serialize<T>(t: &T) -> anyhow::Result<Vec<u8>>
where
T: Serialize,
{
Ok(serde_cbor::to_vec(t)?)
}
pub fn deserialize<T>(v: &[u8]) -> anyhow::Result<T>
where
T: DeserializeOwned,
{
Ok(serde_cbor::from_slice(&v)?)
}
#[cfg(test)]
mod tests {
2020-12-22 05:28:14 +00:00
use crate::state::{Alice, Bob, EndState};
2020-11-03 05:53:28 +00:00
use super::*;
2020-11-03 04:26:47 +00:00
#[tokio::test]
async fn can_write_and_read_to_multiple_keys() {
let db_dir = tempfile::tempdir().unwrap();
let db = Database::open(db_dir.path()).unwrap();
2020-12-22 05:28:14 +00:00
let state_1 = Swap::Alice(Alice::Done(EndState::BtcRedeemed));
2020-11-03 04:26:47 +00:00
let swap_id_1 = Uuid::new_v4();
db.insert_latest_state(swap_id_1, state_1.clone())
.await
.expect("Failed to save second state");
let state_2 = Swap::Bob(Bob::SwapComplete);
let swap_id_2 = Uuid::new_v4();
db.insert_latest_state(swap_id_2, state_2.clone())
.await
.expect("Failed to save first state");
let recovered_1 = db
.get_state(swap_id_1)
2020-11-03 04:26:47 +00:00
.expect("Failed to recover first state");
let recovered_2 = db
.get_state(swap_id_2)
2020-11-03 04:26:47 +00:00
.expect("Failed to recover second state");
assert_eq!(recovered_1, state_1);
assert_eq!(recovered_2, state_2);
}
#[tokio::test]
2020-11-03 04:26:47 +00:00
async fn can_write_twice_to_one_key() {
2020-10-22 08:34:53 +00:00
let db_dir = tempfile::tempdir().unwrap();
let db = Database::open(db_dir.path()).unwrap();
2020-12-22 05:28:14 +00:00
let state = Swap::Alice(Alice::Done(EndState::SafelyAborted));
let swap_id = Uuid::new_v4();
2020-11-03 04:26:47 +00:00
db.insert_latest_state(swap_id, state.clone())
.await
.expect("Failed to save state the first time");
2020-11-03 04:26:47 +00:00
let recovered = db
.get_state(swap_id)
.expect("Failed to recover state the first time");
// We insert and recover twice to ensure database implementation allows the
// caller to write to an existing key
2020-11-03 04:26:47 +00:00
db.insert_latest_state(swap_id, recovered)
.await
.expect("Failed to save state the second time");
2020-11-03 04:26:47 +00:00
let recovered = db
.get_state(swap_id)
.expect("Failed to recover state the second time");
2020-11-03 04:26:47 +00:00
assert_eq!(recovered, state);
}
2020-11-03 04:49:00 +00:00
#[tokio::test]
async fn can_fetch_all_keys() {
let db_dir = tempfile::tempdir().unwrap();
let db = Database::open(db_dir.path()).unwrap();
2020-12-22 05:28:14 +00:00
let state_1 = Swap::Alice(Alice::Done(EndState::BtcPunished));
2020-11-03 04:49:00 +00:00
let swap_id_1 = Uuid::new_v4();
db.insert_latest_state(swap_id_1, state_1.clone())
.await
.expect("Failed to save second state");
let state_2 = Swap::Bob(Bob::SwapComplete);
let swap_id_2 = Uuid::new_v4();
db.insert_latest_state(swap_id_2, state_2.clone())
.await
.expect("Failed to save first state");
let swaps = db.all().unwrap();
assert_eq!(swaps.len(), 2);
assert!(swaps.contains(&(swap_id_1, state_1)));
assert!(swaps.contains(&(swap_id_2, state_2)));
}
}