99 lines
2.6 KiB
Rust
99 lines
2.6 KiB
Rust
use super::{Client, Storage, StorageTxn, Uuid, Version};
|
|
use failure::{format_err, Fallible};
|
|
use std::collections::HashMap;
|
|
use std::sync::{Mutex, MutexGuard};
|
|
|
|
struct Inner {
|
|
/// Clients, indexed by client_id
|
|
clients: HashMap<Uuid, Client>,
|
|
|
|
/// Versions, indexed by (client_id, parent_version_id)
|
|
versions: HashMap<(Uuid, Uuid), Version>,
|
|
}
|
|
|
|
pub(crate) struct InMemoryStorage(Mutex<Inner>);
|
|
|
|
impl InMemoryStorage {
|
|
pub(crate) fn new() -> Self {
|
|
Self(Mutex::new(Inner {
|
|
clients: HashMap::new(),
|
|
versions: HashMap::new(),
|
|
}))
|
|
}
|
|
}
|
|
|
|
struct InnerTxn<'a>(MutexGuard<'a, Inner>);
|
|
|
|
/// In-memory storage for testing and experimentation.
|
|
///
|
|
/// NOTE: this does not implement transaction rollback.
|
|
impl Storage for InMemoryStorage {
|
|
fn txn<'a>(&'a self) -> Fallible<Box<dyn StorageTxn + 'a>> {
|
|
Ok(Box::new(InnerTxn(self.0.lock().expect("poisoned lock"))))
|
|
}
|
|
}
|
|
|
|
impl<'a> StorageTxn for InnerTxn<'a> {
|
|
fn get_client(&mut self, client_id: Uuid) -> Fallible<Option<Client>> {
|
|
Ok(self.0.clients.get(&client_id).cloned())
|
|
}
|
|
|
|
fn new_client(&mut self, client_id: Uuid, latest_version_id: Uuid) -> Fallible<()> {
|
|
if self.0.clients.get(&client_id).is_some() {
|
|
return Err(format_err!("Client {} already exists", client_id));
|
|
}
|
|
self.0
|
|
.clients
|
|
.insert(client_id, Client { latest_version_id });
|
|
Ok(())
|
|
}
|
|
|
|
fn set_client_latest_version_id(
|
|
&mut self,
|
|
client_id: Uuid,
|
|
latest_version_id: Uuid,
|
|
) -> Fallible<()> {
|
|
if let Some(client) = self.0.clients.get_mut(&client_id) {
|
|
client.latest_version_id = latest_version_id;
|
|
Ok(())
|
|
} else {
|
|
Err(format_err!("Client {} does not exist", client_id))
|
|
}
|
|
}
|
|
|
|
fn get_version_by_parent(
|
|
&mut self,
|
|
client_id: Uuid,
|
|
parent_version_id: Uuid,
|
|
) -> Fallible<Option<Version>> {
|
|
Ok(self
|
|
.0
|
|
.versions
|
|
.get(&(client_id, parent_version_id))
|
|
.cloned())
|
|
}
|
|
|
|
fn add_version(
|
|
&mut self,
|
|
client_id: Uuid,
|
|
version_id: Uuid,
|
|
parent_version_id: Uuid,
|
|
history_segment: Vec<u8>,
|
|
) -> Fallible<()> {
|
|
// TODO: verify it doesn't exist (`.entry`?)
|
|
let version = Version {
|
|
version_id,
|
|
parent_version_id,
|
|
history_segment,
|
|
};
|
|
self.0
|
|
.versions
|
|
.insert((client_id, version.parent_version_id), version);
|
|
Ok(())
|
|
}
|
|
|
|
fn commit(&mut self) -> Fallible<()> {
|
|
Ok(())
|
|
}
|
|
}
|