garage/src/model/version_table.rs

205 lines
4.8 KiB
Rust
Raw Normal View History

use serde::{Deserialize, Serialize};
use std::sync::Arc;
2020-04-09 21:45:07 +00:00
2020-04-24 10:10:01 +00:00
use garage_util::background::BackgroundRunner;
use garage_util::data::*;
2020-04-23 17:05:46 +00:00
use garage_table::crdt::*;
2021-03-26 18:41:46 +00:00
use garage_table::replication::TableShardedReplication;
2020-04-24 10:10:01 +00:00
use garage_table::*;
2020-04-09 21:45:07 +00:00
2020-04-24 10:10:01 +00:00
use crate::block_ref_table::*;
use garage_model_050::version_table as old;
2021-03-26 20:53:28 +00:00
/// A version of an object
2020-04-09 21:45:07 +00:00
#[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
pub struct Version {
2021-04-06 03:25:28 +00:00
/// UUID of the version, used as partition key
2021-05-02 21:13:08 +00:00
pub uuid: Uuid,
2020-04-09 21:45:07 +00:00
// Actual data: the blocks for this version
// In the case of a multipart upload, also store the etags
// of individual parts and check them when doing CompleteMultipartUpload
2021-03-26 20:53:28 +00:00
/// Is this version deleted
pub deleted: crdt::Bool,
2021-03-26 20:53:28 +00:00
/// list of blocks of data composing the version
pub blocks: crdt::Map<VersionBlockKey, VersionBlock>,
2021-03-26 20:53:28 +00:00
/// Etag of each part in case of a multipart upload, empty otherwise
pub parts_etags: crdt::Map<u64, String>,
2020-04-09 21:45:07 +00:00
// Back link to bucket+key so that we can figure if
// this was deleted later on
2021-03-26 20:53:28 +00:00
/// Bucket in which the related object is stored
2021-12-14 12:55:11 +00:00
pub bucket_id: Uuid,
2021-03-26 20:53:28 +00:00
/// Key in which the related object is stored
2020-04-09 21:45:07 +00:00
pub key: String,
}
impl Version {
2021-12-14 12:55:11 +00:00
pub fn new(uuid: Uuid, bucket_id: Uuid, key: String, deleted: bool) -> Self {
Self {
uuid,
deleted: deleted.into(),
blocks: crdt::Map::new(),
parts_etags: crdt::Map::new(),
2021-12-14 12:55:11 +00:00
bucket_id,
key,
}
}
2022-01-11 16:31:09 +00:00
pub fn has_part_number(&self, part_number: u64) -> bool {
let case1 = self
.parts_etags
.items()
.binary_search_by(|(k, _)| k.cmp(&part_number))
.is_ok();
let case2 = self
.blocks
.items()
.binary_search_by(|(k, _)| k.part_number.cmp(&part_number))
.is_ok();
case1 || case2
}
}
#[derive(PartialEq, Eq, Clone, Copy, Debug, Serialize, Deserialize)]
pub struct VersionBlockKey {
2021-04-06 03:25:28 +00:00
/// Number of the part
pub part_number: u64,
2021-04-06 03:25:28 +00:00
/// Offset of this sub-segment in its part
pub offset: u64,
}
impl Ord for VersionBlockKey {
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
self.part_number
.cmp(&other.part_number)
.then(self.offset.cmp(&other.offset))
}
}
impl PartialOrd for VersionBlockKey {
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
Some(self.cmp(other))
}
}
2021-03-26 20:53:28 +00:00
/// Informations about a single block
#[derive(PartialEq, Eq, Ord, PartialOrd, Clone, Copy, Debug, Serialize, Deserialize)]
2020-04-09 21:45:07 +00:00
pub struct VersionBlock {
2021-04-08 13:13:02 +00:00
/// Blake2 sum of the block
2020-04-09 21:45:07 +00:00
pub hash: Hash,
2021-03-26 20:53:28 +00:00
/// Size of the block
2020-04-26 20:39:32 +00:00
pub size: u64,
}
2021-05-02 21:13:08 +00:00
impl AutoCrdt for VersionBlock {
const WARN_IF_DIFFERENT: bool = true;
2020-04-09 21:45:07 +00:00
}
2021-12-14 12:55:11 +00:00
impl Entry<Uuid, EmptyKey> for Version {
fn partition_key(&self) -> &Uuid {
2020-04-10 21:11:52 +00:00
&self.uuid
2020-04-09 21:45:07 +00:00
}
fn sort_key(&self) -> &EmptyKey {
&EmptyKey
2020-04-09 21:45:07 +00:00
}
fn is_tombstone(&self) -> bool {
self.deleted.get()
}
}
2020-04-09 21:45:07 +00:00
2021-05-02 21:13:08 +00:00
impl Crdt for Version {
2020-04-09 21:45:07 +00:00
fn merge(&mut self, other: &Self) {
self.deleted.merge(&other.deleted);
if self.deleted.get() {
2020-04-09 21:45:07 +00:00
self.blocks.clear();
self.parts_etags.clear();
} else {
self.blocks.merge(&other.blocks);
self.parts_etags.merge(&other.parts_etags);
2020-04-09 21:45:07 +00:00
}
}
}
pub struct VersionTable {
2020-04-12 11:03:55 +00:00
pub background: Arc<BackgroundRunner>,
pub block_ref_table: Arc<Table<BlockRefTable, TableShardedReplication>>,
2020-04-09 21:45:07 +00:00
}
2020-04-12 20:24:53 +00:00
impl TableSchema for VersionTable {
2021-12-14 11:34:01 +00:00
const TABLE_NAME: &'static str = "version";
2021-12-14 12:55:11 +00:00
type P = Uuid;
type S = EmptyKey;
2020-04-09 21:45:07 +00:00
type E = Version;
type Filter = DeletedFilter;
2020-04-09 21:45:07 +00:00
fn updated(&self, old: Option<Self::E>, new: Option<Self::E>) {
2020-04-12 11:03:55 +00:00
let block_ref_table = self.block_ref_table.clone();
self.background.spawn(async move {
if let (Some(old_v), Some(new_v)) = (old, new) {
// Propagate deletion of version blocks
if new_v.deleted.get() && !old_v.deleted.get() {
let deleted_block_refs = old_v
.blocks
.items()
.iter()
.map(|(_k, vb)| BlockRef {
block: vb.hash,
version: old_v.uuid,
deleted: true.into(),
})
.collect::<Vec<_>>();
block_ref_table.insert_many(&deleted_block_refs[..]).await?;
}
}
Ok(())
})
2020-04-09 21:45:07 +00:00
}
fn matches_filter(entry: &Self::E, filter: &Self::Filter) -> bool {
filter.apply(entry.deleted.get())
}
fn try_migrate(bytes: &[u8]) -> Option<Self::E> {
let old = rmp_serde::decode::from_read_ref::<_, old::Version>(bytes).ok()?;
let blocks = old
.blocks
.items()
.iter()
.map(|(k, v)| {
(
VersionBlockKey {
part_number: k.part_number,
offset: k.offset,
},
VersionBlock {
hash: Hash::try_from(v.hash.as_slice()).unwrap(),
size: v.size,
},
)
})
.collect::<crdt::Map<_, _>>();
let parts_etags = old
.parts_etags
.items()
.iter()
.map(|(k, v)| (*k, v.clone()))
.collect::<crdt::Map<_, _>>();
Some(Version {
uuid: Hash::try_from(old.uuid.as_slice()).unwrap(),
deleted: crdt::Bool::new(old.deleted.get()),
blocks,
parts_etags,
bucket_id: blake2sum(old.bucket.as_bytes()),
key: old.key,
})
}
2020-04-09 21:45:07 +00:00
}