362 lines
12 KiB
Rust
362 lines
12 KiB
Rust
//! This module implements the core logic of the server: handling transactions, upholding
|
|
//! invariants, and so on. This does not implement the HTTP-specific portions; those
|
|
//! are in [`crate::api`]. See the protocol documentation for details.
|
|
use crate::storage::{Client, StorageTxn};
|
|
use uuid::Uuid;
|
|
|
|
/// The distinguished value for "no version"
|
|
pub const NO_VERSION_ID: VersionId = Uuid::nil();
|
|
|
|
pub(crate) type HistorySegment = Vec<u8>;
|
|
pub(crate) type ClientKey = Uuid;
|
|
pub(crate) type VersionId = Uuid;
|
|
|
|
/// Response to get_child_version. See the protocol documentation.
|
|
#[derive(Clone, PartialEq, Debug)]
|
|
pub(crate) enum GetVersionResult {
|
|
NotFound,
|
|
Gone,
|
|
Success {
|
|
version_id: Uuid,
|
|
parent_version_id: Uuid,
|
|
history_segment: HistorySegment,
|
|
},
|
|
}
|
|
|
|
/// Implementation of the GetChildVersion protocol transaction
|
|
pub(crate) fn get_child_version<'a>(
|
|
mut txn: Box<dyn StorageTxn + 'a>,
|
|
client_key: ClientKey,
|
|
client: Client,
|
|
parent_version_id: VersionId,
|
|
) -> anyhow::Result<GetVersionResult> {
|
|
// If a version with parentVersionId equal to the requested parentVersionId exists, it is returned.
|
|
if let Some(version) = txn.get_version_by_parent(client_key, parent_version_id)? {
|
|
return Ok(GetVersionResult::Success {
|
|
version_id: version.version_id,
|
|
parent_version_id: version.parent_version_id,
|
|
history_segment: version.history_segment,
|
|
});
|
|
}
|
|
|
|
// If the requested parentVersionId is the nil UUID ..
|
|
if parent_version_id == NO_VERSION_ID {
|
|
return Ok(match client.snapshot {
|
|
// ..and snapshotVersionId is nil, the response is _not-found_ (the client has no
|
|
// versions).
|
|
None => GetVersionResult::NotFound,
|
|
// ..and snapshotVersionId is not nil, the response is _gone_ (the first version has
|
|
// been deleted).
|
|
Some(_) => GetVersionResult::Gone,
|
|
});
|
|
}
|
|
|
|
// If a version with versionId equal to the requested parentVersionId exists, the response is _not-found_ (the client is up-to-date)
|
|
if txn.get_version(client_key, parent_version_id)?.is_some() {
|
|
return Ok(GetVersionResult::NotFound);
|
|
}
|
|
|
|
// Otherwise, the response is _gone_ (the requested version has been deleted).
|
|
Ok(GetVersionResult::Gone)
|
|
}
|
|
|
|
/// Response to add_version
|
|
#[derive(Clone, PartialEq, Debug)]
|
|
pub(crate) enum AddVersionResult {
|
|
/// OK, version added with the given ID
|
|
Ok(VersionId),
|
|
/// Rejected; expected a version with the given parent version
|
|
ExpectedParentVersion(VersionId),
|
|
}
|
|
|
|
/// Implementation of the AddVersion protocol transaction
|
|
pub(crate) fn add_version<'a>(
|
|
mut txn: Box<dyn StorageTxn + 'a>,
|
|
client_key: ClientKey,
|
|
client: Client,
|
|
parent_version_id: VersionId,
|
|
history_segment: HistorySegment,
|
|
) -> anyhow::Result<AddVersionResult> {
|
|
log::debug!(
|
|
"add_version(client_key: {}, parent_version_id: {})",
|
|
client_key,
|
|
parent_version_id,
|
|
);
|
|
|
|
// check if this version is acceptable, under the protection of the transaction
|
|
if client.latest_version_id != NO_VERSION_ID && parent_version_id != client.latest_version_id {
|
|
log::debug!("add_version request rejected: mismatched latest_version_id");
|
|
return Ok(AddVersionResult::ExpectedParentVersion(
|
|
client.latest_version_id,
|
|
));
|
|
}
|
|
|
|
// invent a version ID
|
|
let version_id = Uuid::new_v4();
|
|
log::debug!(
|
|
"add_version request accepted: new version_id: {}",
|
|
version_id
|
|
);
|
|
|
|
// update the DB
|
|
txn.add_version(client_key, version_id, parent_version_id, history_segment)?;
|
|
txn.commit()?;
|
|
|
|
Ok(AddVersionResult::Ok(version_id))
|
|
}
|
|
|
|
/// Implementation of the GetSnapshot protocol transaction
|
|
pub(crate) fn get_snapshot<'a>(
|
|
mut txn: Box<dyn StorageTxn + 'a>,
|
|
client_key: ClientKey,
|
|
client: Client,
|
|
) -> anyhow::Result<Option<(Uuid, Vec<u8>)>> {
|
|
Ok(if let Some(snap) = client.snapshot {
|
|
txn.get_snapshot_data(client_key, snap.version_id)?
|
|
.map(|data| (snap.version_id, data))
|
|
} else {
|
|
None
|
|
})
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
use crate::storage::{InMemoryStorage, Snapshot, Storage};
|
|
use chrono::{TimeZone, Utc};
|
|
use pretty_assertions::assert_eq;
|
|
|
|
#[test]
|
|
fn gcv_not_found_initial() -> anyhow::Result<()> {
|
|
let storage = InMemoryStorage::new();
|
|
let mut txn = storage.txn()?;
|
|
let client_key = Uuid::new_v4();
|
|
txn.new_client(client_key, NO_VERSION_ID)?;
|
|
|
|
// when no snapshot exists, the first version is NotFound
|
|
let client = txn.get_client(client_key)?.unwrap();
|
|
assert_eq!(
|
|
get_child_version(txn, client_key, client, NO_VERSION_ID)?,
|
|
GetVersionResult::NotFound
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn gcv_gone_initial() -> anyhow::Result<()> {
|
|
let storage = InMemoryStorage::new();
|
|
let mut txn = storage.txn()?;
|
|
let client_key = Uuid::new_v4();
|
|
|
|
txn.new_client(client_key, Uuid::new_v4())?;
|
|
txn.set_snapshot(
|
|
client_key,
|
|
Snapshot {
|
|
version_id: Uuid::new_v4(),
|
|
versions_since: 0,
|
|
timestamp: Utc.ymd(2001, 9, 9).and_hms(1, 46, 40),
|
|
},
|
|
vec![1, 2, 3],
|
|
)?;
|
|
|
|
// when a snapshot exists, the first version is GONE
|
|
let client = txn.get_client(client_key)?.unwrap();
|
|
assert_eq!(
|
|
get_child_version(txn, client_key, client, NO_VERSION_ID)?,
|
|
GetVersionResult::Gone
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn gcv_not_found_up_to_date() -> anyhow::Result<()> {
|
|
let storage = InMemoryStorage::new();
|
|
let mut txn = storage.txn()?;
|
|
let client_key = Uuid::new_v4();
|
|
|
|
// add a parent version, but not the requested child version
|
|
let parent_version_id = Uuid::new_v4();
|
|
txn.new_client(client_key, parent_version_id)?;
|
|
txn.add_version(client_key, parent_version_id, NO_VERSION_ID, vec![])?;
|
|
|
|
let client = txn.get_client(client_key)?.unwrap();
|
|
assert_eq!(
|
|
get_child_version(txn, client_key, client, parent_version_id)?,
|
|
GetVersionResult::NotFound
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn gcv_gone() -> anyhow::Result<()> {
|
|
let storage = InMemoryStorage::new();
|
|
let mut txn = storage.txn()?;
|
|
let client_key = Uuid::new_v4();
|
|
|
|
// make up a parent version id, but neither that version
|
|
// nor its child exists (presumed to have been deleted)
|
|
let parent_version_id = Uuid::new_v4();
|
|
txn.new_client(client_key, Uuid::new_v4())?;
|
|
|
|
let client = txn.get_client(client_key)?.unwrap();
|
|
assert_eq!(
|
|
get_child_version(txn, client_key, client, parent_version_id)?,
|
|
GetVersionResult::Gone
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn gcv_found() -> anyhow::Result<()> {
|
|
let storage = InMemoryStorage::new();
|
|
let mut txn = storage.txn()?;
|
|
let client_key = Uuid::new_v4();
|
|
let version_id = Uuid::new_v4();
|
|
let parent_version_id = Uuid::new_v4();
|
|
let history_segment = b"abcd".to_vec();
|
|
|
|
txn.new_client(client_key, version_id)?;
|
|
txn.add_version(
|
|
client_key,
|
|
version_id,
|
|
parent_version_id,
|
|
history_segment.clone(),
|
|
)?;
|
|
|
|
let client = txn.get_client(client_key)?.unwrap();
|
|
assert_eq!(
|
|
get_child_version(txn, client_key, client, parent_version_id)?,
|
|
GetVersionResult::Success {
|
|
version_id,
|
|
parent_version_id,
|
|
history_segment,
|
|
}
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn av_conflict() -> anyhow::Result<()> {
|
|
let storage = InMemoryStorage::new();
|
|
let mut txn = storage.txn()?;
|
|
let client_key = Uuid::new_v4();
|
|
let parent_version_id = Uuid::new_v4();
|
|
let history_segment = b"abcd".to_vec();
|
|
let existing_parent_version_id = Uuid::new_v4();
|
|
let client = Client {
|
|
latest_version_id: existing_parent_version_id,
|
|
snapshot: None,
|
|
};
|
|
|
|
assert_eq!(
|
|
add_version(txn, client_key, client, parent_version_id, history_segment)?,
|
|
AddVersionResult::ExpectedParentVersion(existing_parent_version_id)
|
|
);
|
|
|
|
// verify that the storage wasn't updated
|
|
txn = storage.txn()?;
|
|
assert_eq!(txn.get_client(client_key)?, None);
|
|
assert_eq!(
|
|
txn.get_version_by_parent(client_key, parent_version_id)?,
|
|
None
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn test_av_success(latest_version_id_nil: bool) -> anyhow::Result<()> {
|
|
let storage = InMemoryStorage::new();
|
|
let mut txn = storage.txn()?;
|
|
let client_key = Uuid::new_v4();
|
|
let parent_version_id = Uuid::new_v4();
|
|
let history_segment = b"abcd".to_vec();
|
|
let latest_version_id = if latest_version_id_nil {
|
|
Uuid::nil()
|
|
} else {
|
|
parent_version_id
|
|
};
|
|
|
|
txn.new_client(client_key, latest_version_id)?;
|
|
let client = txn.get_client(client_key)?.unwrap();
|
|
|
|
let result = add_version(
|
|
txn,
|
|
client_key,
|
|
client,
|
|
parent_version_id,
|
|
history_segment.clone(),
|
|
)?;
|
|
if let AddVersionResult::Ok(new_version_id) = result {
|
|
// check that it invented a new version ID
|
|
assert!(new_version_id != parent_version_id);
|
|
|
|
// verify that the storage was updated
|
|
txn = storage.txn()?;
|
|
let client = txn.get_client(client_key)?.unwrap();
|
|
assert_eq!(client.latest_version_id, new_version_id);
|
|
let version = txn
|
|
.get_version_by_parent(client_key, parent_version_id)?
|
|
.unwrap();
|
|
assert_eq!(version.version_id, new_version_id);
|
|
assert_eq!(version.parent_version_id, parent_version_id);
|
|
assert_eq!(version.history_segment, history_segment);
|
|
} else {
|
|
panic!("did not get Ok from add_version");
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn av_success_with_existing_history() -> anyhow::Result<()> {
|
|
test_av_success(true)
|
|
}
|
|
|
|
#[test]
|
|
fn av_success_nil_latest_version_id() -> anyhow::Result<()> {
|
|
test_av_success(false)
|
|
}
|
|
|
|
#[test]
|
|
fn get_snapshot_found() -> anyhow::Result<()> {
|
|
let storage = InMemoryStorage::new();
|
|
let mut txn = storage.txn()?;
|
|
let client_key = Uuid::new_v4();
|
|
let data = vec![1, 2, 3];
|
|
let snapshot_version_id = Uuid::new_v4();
|
|
|
|
txn.new_client(client_key, snapshot_version_id)?;
|
|
txn.set_snapshot(
|
|
client_key,
|
|
Snapshot {
|
|
version_id: snapshot_version_id,
|
|
versions_since: 3,
|
|
timestamp: Utc.ymd(2001, 9, 9).and_hms(1, 46, 40),
|
|
},
|
|
data.clone(),
|
|
)?;
|
|
|
|
let client = txn.get_client(client_key)?.unwrap();
|
|
assert_eq!(
|
|
get_snapshot(txn, client_key, client)?,
|
|
Some((snapshot_version_id, data.clone()))
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn get_snapshot_not_found() -> anyhow::Result<()> {
|
|
let storage = InMemoryStorage::new();
|
|
let mut txn = storage.txn()?;
|
|
let client_key = Uuid::new_v4();
|
|
|
|
txn.new_client(client_key, NO_VERSION_ID)?;
|
|
let client = txn.get_client(client_key)?.unwrap();
|
|
|
|
assert_eq!(get_snapshot(txn, client_key, client)?, None);
|
|
|
|
Ok(())
|
|
}
|
|
}
|