use std::path::Path;
use super::FormatFault;
use super::fs::SegFs;
use super::sidecar::OrderKind;
use crate::entry::SEQUENCE_MASK;
use crate::error::{DbError, DbResult};
pub(crate) const MANIFEST_NAME: &str = "MANIFEST";
pub(crate) const MANIFEST_TMP: &str = "MANIFEST.tmp";
pub(crate) const MANIFEST_MAGIC: [u8; 4] = *b"ASM1";
pub(crate) const MANIFEST_FORMAT_VERSION: u16 = 1;
const FIXED_LEN: usize = 72;
const GEN_RECORD_LEN: usize = 48;
const SEG_RECORD_LEN: usize = 120;
const CRC_LEN: usize = 4;
pub(crate) const MAX_GENERATIONS: usize = 1024;
pub(crate) const MAX_SEGMENTS: usize = 65_536;
pub(crate) const MAX_MANIFEST_LEN: u64 =
(FIXED_LEN + MAX_GENERATIONS * GEN_RECORD_LEN + MAX_SEGMENTS * SEG_RECORD_LEN + CRC_LEN) as u64;
const LOCATION_LOCAL: u8 = 0;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u8)]
pub(crate) enum GenState {
Active = 1,
Frozen = 2,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct GenRecord {
pub gen_id: u64,
pub state: GenState,
pub shard_count: u8,
pub opened_at_ms: u64,
pub frozen_at_ms: u64,
pub min_gsn: u64,
pub max_gsn: u64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u8)]
pub(crate) enum SegState {
Sealed = 1,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum Location {
Local,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct SegRecord {
pub segment_id: u64,
pub version: u32,
pub state: SegState,
pub order: OrderKind,
pub format_version: u16,
pub min_gsn: u64,
pub max_gsn: u64,
pub entries: u64,
pub tombstones: u64,
pub opened_at_ms: u64,
pub frozen_at_ms: u64,
pub sealed_at_ms: u64,
pub sdat_len: u64,
pub sdat_checksum: u64,
pub sidx_len: u64,
pub sidx_checksum: u64,
pub typ_hash: u64,
pub value_version: u16,
pub location: Location,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Manifest {
pub manifest_version: u64,
pub key_len: u16,
pub order: OrderKind,
pub seed: u64,
pub created_at_ms: u64,
pub next_segment_id: u64,
pub next_gen_id: u64,
pub gsn_floor: u64,
pub generations: Vec<GenRecord>,
pub segments: Vec<SegRecord>,
}
fn broken(what: &'static str) -> DbError {
DbError::Internal(what)
}
impl Manifest {
pub(crate) fn new(key_len: u16, seed: u64, created_at_ms: u64) -> Self {
Self {
manifest_version: 1,
key_len,
order: OrderKind::ByHash,
seed,
created_at_ms,
next_segment_id: 1,
next_gen_id: 1,
gsn_floor: 0,
generations: Vec::new(),
segments: Vec::new(),
}
}
pub(crate) fn active(&self) -> Option<&GenRecord> {
self.generations
.last()
.filter(|g| g.state == GenState::Active)
}
pub(crate) fn oldest_frozen(&self) -> Option<&GenRecord> {
self.generations
.first()
.filter(|g| g.state == GenState::Frozen)
}
pub(crate) fn frozen_count(&self) -> usize {
self.generations
.iter()
.filter(|g| g.state == GenState::Frozen)
.count()
}
fn newest_layer_time_ms(&self) -> u64 {
let from_generations = self
.generations
.iter()
.map(|g| g.opened_at_ms.max(g.frozen_at_ms))
.max();
let from_segments = self
.segments
.iter()
.map(|s| s.opened_at_ms.max(s.frozen_at_ms))
.max();
from_generations.max(from_segments).unwrap_or(0)
}
pub(crate) fn monotone_time(&self, now_ms: u64) -> u64 {
now_ms.max(self.newest_layer_time_ms())
}
pub(crate) fn check(&self) -> Result<(), String> {
if self.key_len == 0 {
return Err("key length is zero".into());
}
if self.manifest_version == 0 || self.next_segment_id == 0 || self.next_gen_id == 0 {
return Err("manifest version or next id is zero".into());
}
if self.generations.len() > MAX_GENERATIONS {
return Err(format!(
"too many generations: {} > {MAX_GENERATIONS}",
self.generations.len()
));
}
if self.segments.len() > MAX_SEGMENTS {
return Err(format!(
"too many segments: {} > {MAX_SEGMENTS}",
self.segments.len()
));
}
let mut gsns = std::iter::once(self.gsn_floor)
.chain(self.generations.iter().flat_map(|g| [g.min_gsn, g.max_gsn]))
.chain(self.segments.iter().flat_map(|s| [s.min_gsn, s.max_gsn]));
if let Some(gsn) = gsns.find(|gsn| *gsn > SEQUENCE_MASK) {
return Err(format!("GSN {gsn:#x} is outside the sequence range"));
}
let mut previous_id = 0u64;
for s in &self.segments {
if s.version != 1 || s.format_version != 1 {
return Err("segment version is unsupported".into());
}
if s.order != self.order {
return Err("segment order differs from manifest order".into());
}
if s.entries == 0 {
return Err(format!("segment {:#x} has no entries", s.segment_id));
}
if s.tombstones > s.entries {
return Err("segment tombstones exceed entries".into());
}
if s.opened_at_ms > s.frozen_at_ms {
return Err(format!(
"segment {:#x} was frozen at {} before it was opened at {}",
s.segment_id, s.frozen_at_ms, s.opened_at_ms
));
}
if s.frozen_at_ms > s.sealed_at_ms {
return Err(format!(
"segment {:#x} was sealed at {} before it was frozen at {}",
s.segment_id, s.sealed_at_ms, s.frozen_at_ms
));
}
if s.segment_id <= previous_id {
return Err(format!(
"segment ids are not increasing at {:#x}",
s.segment_id
));
}
previous_id = s.segment_id;
}
if previous_id >= self.next_segment_id {
return Err(format!(
"segment {previous_id:#x} is not below next_segment_id {:#x}",
self.next_segment_id
));
}
let mut previous_id = 0u64;
for (i, g) in self.generations.iter().enumerate() {
if g.gen_id <= previous_id {
return Err(format!(
"generation ids are not increasing at {:#x}",
g.gen_id
));
}
previous_id = g.gen_id;
if g.shard_count == 0 {
return Err(format!("generation {:#x} has no shards", g.gen_id));
}
let last = i + 1 == self.generations.len();
if g.state == GenState::Active && !last {
return Err(format!(
"generation {:#x} is active but is not the newest; only one active generation is allowed",
g.gen_id
));
}
if g.state == GenState::Active && (g.frozen_at_ms != 0 || g.max_gsn != 0) {
return Err("active generation has frozen fields".into());
}
if g.state == GenState::Frozen && g.opened_at_ms > g.frozen_at_ms {
return Err(format!(
"generation {:#x} was frozen at {} before it was opened at {}",
g.gen_id, g.frozen_at_ms, g.opened_at_ms
));
}
}
if previous_id >= self.next_gen_id {
return Err(format!(
"generation {previous_id:#x} is not below next_gen_id {:#x}",
self.next_gen_id
));
}
let mut previous_max_gsn = 0u64;
let mut previous_frozen_at = 0u64;
let sealed = self
.segments
.iter()
.map(|s| (s.min_gsn, Some(s.max_gsn), Some(s.frozen_at_ms)));
let generations = self.generations.iter().map(|g| match g.state {
GenState::Frozen => (g.min_gsn, Some(g.max_gsn), Some(g.frozen_at_ms)),
GenState::Active => (g.min_gsn, None, None),
});
for (min_gsn, max_gsn, frozen_at) in sealed.chain(generations) {
if min_gsn <= previous_max_gsn {
return Err(format!(
"GSN ranges overlap: a layer starts at {min_gsn}, the one before ends at {previous_max_gsn}"
));
}
if let Some(max) = max_gsn {
if max < min_gsn {
return Err(format!("GSN range {min_gsn}..={max} is reversed"));
}
if max > self.gsn_floor {
return Err(format!(
"gsn_floor {} is below a frozen GSN {max}",
self.gsn_floor
));
}
previous_max_gsn = max;
}
if let Some(at) = frozen_at {
if at < previous_frozen_at {
return Err(format!(
"layer freeze time {at} goes back before {previous_frozen_at}"
));
}
previous_frozen_at = at;
}
}
if let Some(active) = self.active()
&& active.min_gsn <= self.gsn_floor
{
return Err("active generation is below gsn_floor".into());
}
Ok(())
}
fn next(&self) -> DbResult<Self> {
let mut m = self.clone();
m.manifest_version = m
.manifest_version
.checked_add(1)
.ok_or_else(|| broken("manifest version exhausted"))?;
Ok(m)
}
fn checked(self) -> DbResult<Self> {
match self.check() {
Ok(()) => Ok(self),
Err(reason) => {
tracing::error!(reason, "manifest mutation broke an invariant");
Err(broken("manifest mutation broke an invariant"))
}
}
}
pub(crate) fn reserve_gen_id(&self) -> DbResult<(Self, u64)> {
if self.check().is_err() {
return Err(broken("cannot reserve from an invalid manifest"));
}
let mut m = self.next()?;
let id = m.next_gen_id;
m.next_gen_id = id
.checked_add(1)
.ok_or_else(|| broken("generation ids exhausted"))?;
Ok((m.checked()?, id))
}
pub(crate) fn reserve_segment_id(&self) -> DbResult<(Self, u64)> {
if self.check().is_err() {
return Err(broken("cannot reserve from an invalid manifest"));
}
let mut m = self.next()?;
let id = m.next_segment_id;
m.next_segment_id = id
.checked_add(1)
.ok_or_else(|| broken("segment ids exhausted"))?;
Ok((m.checked()?, id))
}
pub(crate) fn with_active(&self, new: GenRecord) -> DbResult<Self> {
if self.active().is_some() || new.state != GenState::Active {
return Err(broken(
"with_active needs a manifest without an active generation",
));
}
let mut m = self.next()?;
m.generations.push(new);
m.checked()
}
pub(crate) fn with_freeze(
&self,
frozen_at_ms: u64,
max_gsn: u64,
new: GenRecord,
) -> DbResult<Self> {
if self.active().is_none() || new.state != GenState::Active {
return Err(broken("with_freeze needs an active generation"));
}
let mut m = self.next()?;
let old = m.generations.last_mut().expect("checked above");
old.state = GenState::Frozen;
old.frozen_at_ms = frozen_at_ms;
old.max_gsn = max_gsn;
m.gsn_floor = m.gsn_floor.max(max_gsn);
m.generations.push(new);
m.checked()
}
pub(crate) fn with_sealed(&self, gen_id: u64, segment: Option<SegRecord>) -> DbResult<Self> {
self.sealed(gen_id, segment, false)
}
pub(crate) fn with_empty_sealed(&self, gen_id: u64) -> DbResult<Self> {
self.sealed(gen_id, None, true)
}
fn sealed(
&self,
gen_id: u64,
segment: Option<SegRecord>,
generation_empty: bool,
) -> DbResult<Self> {
let Some(oldest) = self.oldest_frozen() else {
return Err(broken("with_sealed needs a frozen generation"));
};
if oldest.gen_id != gen_id {
return Err(broken("only the oldest frozen generation may be sealed"));
}
if let Some(s) = &segment {
if s.min_gsn < oldest.min_gsn || s.max_gsn > oldest.max_gsn {
return Err(broken("sealed segment GSN range leaves generation bounds"));
}
if (s.opened_at_ms, s.frozen_at_ms) != (oldest.opened_at_ms, oldest.frozen_at_ms) {
return Err(broken("sealed segment times differ from generation"));
}
} else if !generation_empty && !self.segments.is_empty() {
return Err(broken("empty seal could expose values in older segments"));
}
let max_gsn = oldest.max_gsn;
let mut m = self.next()?;
m.generations.remove(0);
m.gsn_floor = m.gsn_floor.max(max_gsn);
if let Some(segment) = segment {
m.segments.push(segment);
}
m.checked()
}
pub(crate) fn without_oldest_segment(&self) -> DbResult<Self> {
if self.segments.is_empty() {
return Err(broken("there is no segment to drop"));
}
let mut m = self.next()?;
m.segments.remove(0);
m.checked()
}
}
fn u16_at(b: &[u8], at: usize) -> u16 {
u16::from_le_bytes(b[at..at + 2].try_into().expect("2 bytes"))
}
fn u32_at(b: &[u8], at: usize) -> u32 {
u32::from_le_bytes(b[at..at + 4].try_into().expect("4 bytes"))
}
fn u64_at(b: &[u8], at: usize) -> u64 {
u64::from_le_bytes(b[at..at + 8].try_into().expect("8 bytes"))
}
impl Manifest {
pub(crate) fn encode(&self) -> Vec<u8> {
let mut out = Vec::with_capacity(
FIXED_LEN
+ self.generations.len() * GEN_RECORD_LEN
+ self.segments.len() * SEG_RECORD_LEN
+ CRC_LEN,
);
out.extend_from_slice(&MANIFEST_MAGIC);
out.extend_from_slice(&MANIFEST_FORMAT_VERSION.to_le_bytes());
out.extend_from_slice(&[0u8; 2]);
out.extend_from_slice(&self.manifest_version.to_le_bytes());
out.extend_from_slice(&self.key_len.to_le_bytes());
out.push(self.order as u8);
out.extend_from_slice(&[0u8; 5]);
out.extend_from_slice(&self.seed.to_le_bytes());
out.extend_from_slice(&self.created_at_ms.to_le_bytes());
out.extend_from_slice(&self.next_segment_id.to_le_bytes());
out.extend_from_slice(&self.next_gen_id.to_le_bytes());
out.extend_from_slice(&self.gsn_floor.to_le_bytes());
out.extend_from_slice(&(self.generations.len() as u32).to_le_bytes());
out.extend_from_slice(&(self.segments.len() as u32).to_le_bytes());
debug_assert_eq!(out.len(), FIXED_LEN);
for g in &self.generations {
out.extend_from_slice(&g.gen_id.to_le_bytes());
out.push(g.state as u8);
out.push(g.shard_count);
out.extend_from_slice(&[0u8; 6]);
out.extend_from_slice(&g.opened_at_ms.to_le_bytes());
out.extend_from_slice(&g.frozen_at_ms.to_le_bytes());
out.extend_from_slice(&g.min_gsn.to_le_bytes());
out.extend_from_slice(&g.max_gsn.to_le_bytes());
}
for s in &self.segments {
out.extend_from_slice(&s.segment_id.to_le_bytes());
out.extend_from_slice(&s.version.to_le_bytes());
out.push(s.state as u8);
out.push(s.order as u8);
out.extend_from_slice(&s.format_version.to_le_bytes());
for v in [
s.min_gsn,
s.max_gsn,
s.entries,
s.tombstones,
s.opened_at_ms,
s.frozen_at_ms,
s.sealed_at_ms,
s.sdat_len,
s.sdat_checksum,
s.sidx_len,
s.sidx_checksum,
s.typ_hash,
] {
out.extend_from_slice(&v.to_le_bytes());
}
out.extend_from_slice(&s.value_version.to_le_bytes());
match s.location {
Location::Local => {
out.push(LOCATION_LOCAL);
out.push(0);
out.extend_from_slice(&0u32.to_le_bytes());
}
}
}
let crc = crc32fast::hash(&out);
out.extend_from_slice(&crc.to_le_bytes());
out
}
pub(crate) fn decode(bytes: &[u8]) -> Result<Self, FormatFault> {
if bytes.len() < FIXED_LEN + CRC_LEN {
return Err(FormatFault::corrupt("manifest is truncated"));
}
if bytes[0..4] != MANIFEST_MAGIC {
return Err(FormatFault::corrupt("bad manifest magic"));
}
let body = &bytes[..bytes.len() - CRC_LEN];
let stored = u32_at(bytes, bytes.len() - CRC_LEN);
let computed = crc32fast::hash(body);
if stored != computed {
return Err(FormatFault::corrupt(format!(
"manifest CRC mismatch: stored {stored:#x}, computed {computed:#x}"
)));
}
let version = u16_at(body, 4);
if version != MANIFEST_FORMAT_VERSION {
return Err(FormatFault::unsupported(format!(
"manifest format version {version}"
)));
}
if body[6..8]
.iter()
.chain(body[19..24].iter())
.any(|b| *b != 0)
{
return Err(FormatFault::unsupported("manifest reserved bytes are set"));
}
let order = OrderKind::from_byte(body[18])
.ok_or_else(|| FormatFault::unsupported(format!("entry order {}", body[18])))?;
let generation_count = u32_at(body, 64) as usize;
let segment_count = u32_at(body, 68) as usize;
let mut at = FIXED_LEN;
let need = |at: usize, len: usize| {
if at + len > body.len() {
Err(FormatFault::corrupt("manifest record runs past the end"))
} else {
Ok(())
}
};
let mut generations = Vec::with_capacity(generation_count.min(1024));
for _ in 0..generation_count {
need(at, GEN_RECORD_LEN)?;
let r = &body[at..at + GEN_RECORD_LEN];
if r[10..16].iter().any(|b| *b != 0) {
return Err(FormatFault::unsupported(
"generation reserved bytes are set",
));
}
let state = match r[8] {
1 => GenState::Active,
2 => GenState::Frozen,
other => {
return Err(FormatFault::unsupported(format!(
"generation state {other}"
)));
}
};
generations.push(GenRecord {
gen_id: u64_at(r, 0),
state,
shard_count: r[9],
opened_at_ms: u64_at(r, 16),
frozen_at_ms: u64_at(r, 24),
min_gsn: u64_at(r, 32),
max_gsn: u64_at(r, 40),
});
at += GEN_RECORD_LEN;
}
let mut segments = Vec::with_capacity(segment_count.min(1024));
for _ in 0..segment_count {
need(at, SEG_RECORD_LEN)?;
let r = &body[at..at + SEG_RECORD_LEN];
if r[115] != 0 {
return Err(FormatFault::unsupported("segment reserved byte is set"));
}
let state = match r[12] {
1 => SegState::Sealed,
other => {
return Err(FormatFault::unsupported(format!("segment state {other}")));
}
};
let segment_order = OrderKind::from_byte(r[13])
.ok_or_else(|| FormatFault::unsupported(format!("entry order {}", r[13])))?;
if segment_order != order {
return Err(FormatFault::corrupt(
"segment order differs from manifest order",
));
}
if u32_at(r, 8) != 1 {
return Err(FormatFault::unsupported(format!(
"segment version {}",
u32_at(r, 8)
)));
}
if u16_at(r, 14) != 1 {
return Err(FormatFault::unsupported(format!(
"segment format version {}",
u16_at(r, 14)
)));
}
let location_kind = r[114];
let location_len = u32_at(r, 116) as usize;
if location_kind != LOCATION_LOCAL {
return Err(FormatFault::unsupported(format!(
"segment location kind {location_kind}"
)));
}
if location_len != 0 {
return Err(FormatFault::corrupt(
"a local segment has a location payload",
));
}
segments.push(SegRecord {
segment_id: u64_at(r, 0),
version: u32_at(r, 8),
state,
order,
format_version: u16_at(r, 14),
min_gsn: u64_at(r, 16),
max_gsn: u64_at(r, 24),
entries: u64_at(r, 32),
tombstones: u64_at(r, 40),
opened_at_ms: u64_at(r, 48),
frozen_at_ms: u64_at(r, 56),
sealed_at_ms: u64_at(r, 64),
sdat_len: u64_at(r, 72),
sdat_checksum: u64_at(r, 80),
sidx_len: u64_at(r, 88),
sidx_checksum: u64_at(r, 96),
typ_hash: u64_at(r, 104),
value_version: u16_at(r, 112),
location: Location::Local,
});
at += SEG_RECORD_LEN + location_len;
}
if at != body.len() {
return Err(FormatFault::corrupt(format!(
"manifest has {} bytes after its last record",
body.len() - at
)));
}
let manifest = Self {
manifest_version: u64_at(body, 8),
key_len: u16_at(body, 16),
order,
seed: u64_at(body, 24),
created_at_ms: u64_at(body, 32),
next_segment_id: u64_at(body, 40),
next_gen_id: u64_at(body, 48),
gsn_floor: u64_at(body, 56),
generations,
segments,
};
manifest.check().map_err(FormatFault::Corrupt)?;
Ok(manifest)
}
}
#[derive(Debug)]
pub(crate) enum PublishError {
NotPublished(DbError),
Indeterminate(DbError),
}
impl PublishError {
pub(crate) fn into_inner(self) -> DbError {
match self {
Self::NotPublished(error) | Self::Indeterminate(error) => error,
}
}
}
pub(crate) fn publish(fs: &dyn SegFs, dir: &Path, manifest: &Manifest) -> Result<(), PublishError> {
if let Err(reason) = manifest.check() {
tracing::error!(reason, path = %dir.display(), "refusing to publish an invalid manifest");
return Err(PublishError::NotPublished(broken(
"refusing to publish a manifest that breaks an invariant",
)));
}
let tmp = dir.join(MANIFEST_TMP);
let dst = dir.join(MANIFEST_NAME);
let bytes = manifest.encode();
let staged = (|| -> std::io::Result<()> {
let mut file = fs.create(&tmp)?;
fs.write_all(&mut file, &tmp, &bytes)?;
fs.sync_file(&file, &tmp)?;
drop(file);
super::failpoint!(MANIFEST_TMP_WRITTEN);
fs.rename(&tmp, &dst)
})();
if let Err(error) = staged {
if let Err(cleanup) = fs.remove_file(&tmp) {
tracing::warn!(error = %cleanup, path = %tmp.display(), "could not remove the temporary manifest");
}
return Err(PublishError::NotPublished(error.into()));
}
super::failpoint!(MANIFEST_RENAMED);
fs.sync_dir(dir)
.map_err(|error| PublishError::Indeterminate(error.into()))
}
pub(crate) fn load(dir: &Path) -> DbResult<Option<Manifest>> {
use std::io::Read;
let path = dir.join(MANIFEST_NAME);
let file = match std::fs::File::open(&path) {
Ok(file) => file,
Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None),
Err(error) => return Err(error.into()),
};
let too_large = |len: u64| DbError::ManifestCorrupt {
path: path.clone(),
reason: format!("manifest is {len} bytes, larger than the {MAX_MANIFEST_LEN}-byte maximum"),
};
let len = file.metadata()?.len();
if len > MAX_MANIFEST_LEN {
return Err(too_large(len));
}
let mut bytes = Vec::with_capacity(len as usize);
file.take(MAX_MANIFEST_LEN + 1).read_to_end(&mut bytes)?;
if bytes.len() as u64 > MAX_MANIFEST_LEN {
return Err(too_large(bytes.len() as u64));
}
match Manifest::decode(&bytes) {
Ok(manifest) => Ok(Some(manifest)),
Err(FormatFault::Unsupported(reason)) => Err(DbError::FormatMismatch(format!(
"{}: {reason}",
path.display()
))),
Err(FormatFault::Corrupt(reason)) => Err(DbError::ManifestCorrupt { path, reason }),
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::error::DbError;
use crate::seg::fs::{FsOp, FsOpKind, TraceFs};
fn first() -> Manifest {
Manifest::new(32, 7, 1)
}
fn second() -> Manifest {
first().reserve_gen_id().unwrap().0
}
#[test]
fn publication_follows_the_durable_order() {
let dir = tempfile::tempdir().unwrap();
let fs = TraceFs::new();
publish(&*fs, dir.path(), &first()).unwrap();
let tmp = dir.path().join(MANIFEST_TMP);
let dst = dir.path().join(MANIFEST_NAME);
assert_eq!(
fs.ops(),
[
FsOp::Create(tmp.clone()),
FsOp::WriteAll(tmp.clone()),
FsOp::SyncFile(tmp.clone()),
FsOp::Rename(tmp, dst),
FsOp::SyncDir(dir.path().to_path_buf()),
]
);
assert_eq!(load(dir.path()).unwrap(), Some(first()));
assert!(!dir.path().join(MANIFEST_TMP).exists());
}
#[test]
fn an_invalid_manifest_is_never_published() {
let dir = tempfile::tempdir().unwrap();
let fs = TraceFs::new();
let mut bad = sample();
bad.key_len = 0;
let mut floor_below_a_layer = sample();
floor_below_a_layer.gsn_floor = 250;
for manifest in [Manifest::new(0, 7, 1), bad, floor_below_a_layer] {
assert!(manifest.check().is_err());
let err = publish(&*fs, dir.path(), &manifest).unwrap_err();
assert!(
matches!(err, PublishError::NotPublished(DbError::Internal(_))),
"{err:?}"
);
assert!(fs.ops().is_empty(), "no file operation: {:?}", fs.ops());
assert!(!dir.path().join(MANIFEST_NAME).exists());
assert!(!dir.path().join(MANIFEST_TMP).exists());
}
}
#[test]
fn a_failure_before_the_rename_publishes_nothing() {
for kind in [FsOpKind::Create, FsOpKind::SyncFile, FsOpKind::Rename] {
let dir = tempfile::tempdir().unwrap();
let fs = TraceFs::new();
publish(&*fs, dir.path(), &first()).unwrap();
fs.fail_on(kind, "MANIFEST", 0);
let err = publish(&*fs, dir.path(), &second()).unwrap_err();
assert!(
matches!(err, PublishError::NotPublished(_)),
"{kind:?}: {err:?}"
);
assert_eq!(
load(dir.path()).unwrap(),
Some(first()),
"{kind:?}: the previous manifest must stay in force"
);
assert!(
!dir.path().join(MANIFEST_TMP).exists(),
"{kind:?}: the temporary file must be removed"
);
publish(&*fs, dir.path(), &second()).unwrap();
assert_eq!(load(dir.path()).unwrap(), Some(second()));
}
}
#[test]
fn a_write_failure_preserves_the_published_manifest_and_allows_retry() {
let dir = tempfile::tempdir().unwrap();
let fs = TraceFs::new();
publish(&*fs, dir.path(), &first()).unwrap();
fs.fail_on(FsOpKind::WriteAll, MANIFEST_TMP, 0);
let err = publish(&*fs, dir.path(), &second()).unwrap_err();
assert!(matches!(err, PublishError::NotPublished(_)), "{err:?}");
assert_eq!(load(dir.path()).unwrap(), Some(first()));
assert!(!dir.path().join(MANIFEST_TMP).exists());
publish(&*fs, dir.path(), &second()).unwrap();
assert_eq!(load(dir.path()).unwrap(), Some(second()));
}
#[test]
fn a_failed_directory_fsync_is_indeterminate() {
let dir = tempfile::tempdir().unwrap();
let fs = TraceFs::new();
publish(&*fs, dir.path(), &first()).unwrap();
fs.fail_on(FsOpKind::SyncDir, "", 0);
let err = publish(&*fs, dir.path(), &second()).unwrap_err();
assert!(matches!(err, PublishError::Indeterminate(_)), "{err:?}");
assert_eq!(load(dir.path()).unwrap(), Some(second()));
}
#[test]
fn loading_distinguishes_absent_corrupt_and_unsupported() {
let dir = tempfile::tempdir().unwrap();
assert_eq!(load(dir.path()).unwrap(), None);
let path = dir.path().join(MANIFEST_NAME);
std::fs::write(&path, vec![b'x'; FIXED_LEN + CRC_LEN]).unwrap();
match load(dir.path()).unwrap_err() {
DbError::ManifestCorrupt { path: p, reason } => {
assert_eq!(p, path);
assert!(reason.contains("magic"), "{reason}");
}
other => panic!("{other:?}"),
}
let mut newer = first().encode();
newer[4] = 2;
let at = newer.len() - 4;
let crc = crc32fast::hash(&newer[..at]);
newer[at..].copy_from_slice(&crc.to_le_bytes());
std::fs::write(&path, newer).unwrap();
assert!(matches!(
load(dir.path()).unwrap_err(),
DbError::FormatMismatch(m) if m.contains("version")
));
}
#[test]
fn a_leftover_temporary_file_does_not_affect_loading() {
let dir = tempfile::tempdir().unwrap();
let fs = TraceFs::new();
publish(&*fs, dir.path(), &first()).unwrap();
std::fs::write(dir.path().join(MANIFEST_TMP), b"torn").unwrap();
assert_eq!(load(dir.path()).unwrap(), Some(first()));
}
fn seg(id: u64, min_gsn: u64, max_gsn: u64, frozen_at_ms: u64) -> SegRecord {
SegRecord {
segment_id: id,
version: 1,
state: SegState::Sealed,
order: OrderKind::ByHash,
format_version: 1,
min_gsn,
max_gsn,
entries: max_gsn - min_gsn + 1,
tombstones: 0,
opened_at_ms: frozen_at_ms - 10,
frozen_at_ms,
sealed_at_ms: frozen_at_ms + 5,
sdat_len: 4096,
sdat_checksum: 0xaaaa,
sidx_len: 512,
sidx_checksum: 0xbbbb,
typ_hash: 0xcccc,
value_version: 3,
location: Location::Local,
}
}
fn frozen(id: u64, min_gsn: u64, max_gsn: u64, frozen_at_ms: u64) -> GenRecord {
GenRecord {
gen_id: id,
state: GenState::Frozen,
shard_count: 4,
opened_at_ms: frozen_at_ms - 10,
frozen_at_ms,
min_gsn,
max_gsn,
}
}
fn active(id: u64, min_gsn: u64, opened_at_ms: u64) -> GenRecord {
GenRecord {
gen_id: id,
state: GenState::Active,
shard_count: 8,
opened_at_ms,
frozen_at_ms: 0,
min_gsn,
max_gsn: 0,
}
}
fn sample() -> Manifest {
Manifest {
manifest_version: 9,
key_len: 32,
order: OrderKind::ByHash,
seed: 0x1234,
created_at_ms: 50,
next_segment_id: 3,
next_gen_id: 5,
gsn_floor: 300,
generations: vec![frozen(3, 201, 300, 3_000), active(4, 301, 3_000)],
segments: vec![seg(1, 1, 100, 1_000), seg(2, 101, 200, 2_000)],
}
}
fn reseal(bytes: &mut [u8]) {
let at = bytes.len() - 4;
let crc = crc32fast::hash(&bytes[..at]);
bytes[at..].copy_from_slice(&crc.to_le_bytes());
}
fn decode_edited(edit: impl FnOnce(&mut Vec<u8>)) -> Result<Manifest, FormatFault> {
let mut bytes = sample().encode();
edit(&mut bytes);
reseal(&mut bytes);
Manifest::decode(&bytes)
}
const GEN0: usize = 72;
const SEG0: usize = 72 + 2 * 48;
#[test]
fn manifest_orders_must_agree() {
let mut m = sample();
m.order = OrderKind::ByKey;
for s in &mut m.segments {
s.order = OrderKind::ByKey;
}
assert_eq!(Manifest::decode(&m.encode()).unwrap(), m);
for offset in [18, SEG0 + 13] {
assert!(matches!(
decode_edited(|b| b[offset] = 1),
Err(FormatFault::Corrupt(_))
));
}
}
#[test]
fn a_manifest_round_trips() {
let m = sample();
m.check().unwrap();
assert_eq!(Manifest::decode(&m.encode()).unwrap(), m);
let empty = Manifest::new(32, 7, 1);
empty.check().unwrap();
assert_eq!(Manifest::decode(&empty.encode()).unwrap(), empty);
assert_eq!(empty.manifest_version, 1);
assert_eq!(empty.next_gen_id, 1);
assert_eq!(empty.next_segment_id, 1);
}
#[test]
fn the_fixed_part_has_the_documented_layout() {
let bytes = sample().encode();
assert_eq!(&bytes[0..4], b"ASM1");
assert_eq!(u16::from_le_bytes([bytes[4], bytes[5]]), 1);
assert_eq!(u64::from_le_bytes(bytes[8..16].try_into().unwrap()), 9);
assert_eq!(u16::from_le_bytes([bytes[16], bytes[17]]), 32);
assert_eq!(bytes[18], 0);
assert_eq!(
u64::from_le_bytes(bytes[24..32].try_into().unwrap()),
0x1234
);
assert_eq!(u64::from_le_bytes(bytes[40..48].try_into().unwrap()), 3);
assert_eq!(u64::from_le_bytes(bytes[48..56].try_into().unwrap()), 5);
assert_eq!(u64::from_le_bytes(bytes[56..64].try_into().unwrap()), 300);
assert_eq!(u32::from_le_bytes(bytes[64..68].try_into().unwrap()), 2);
assert_eq!(u32::from_le_bytes(bytes[68..72].try_into().unwrap()), 2);
assert_eq!(bytes.len(), 72 + 2 * 48 + 2 * 120 + 4);
assert_eq!(
u64::from_le_bytes(bytes[GEN0..GEN0 + 8].try_into().unwrap()),
3
);
assert_eq!(bytes[GEN0 + 8], 2, "frozen");
assert_eq!(bytes[GEN0 + 9], 4, "shard count");
assert_eq!(
u64::from_le_bytes(bytes[SEG0..SEG0 + 8].try_into().unwrap()),
1
);
}
#[test]
fn damage_is_detected() {
let good = sample().encode();
let mut magic = good.clone();
magic[0] = b'Z';
assert!(matches!(
Manifest::decode(&magic),
Err(FormatFault::Corrupt(m)) if m.contains("magic")
));
let mut flipped = good.clone();
flipped[30] ^= 1;
assert!(matches!(
Manifest::decode(&flipped),
Err(FormatFault::Corrupt(m)) if m.contains("CRC")
));
for cut in [0, 3, 71, good.len() - 1] {
assert!(
matches!(Manifest::decode(&good[..cut]), Err(FormatFault::Corrupt(_))),
"cut at {cut}"
);
}
}
#[test]
fn what_this_build_cannot_read_is_refused() {
assert!(matches!(
decode_edited(|b| b[4] = 2),
Err(FormatFault::Unsupported(m)) if m.contains("version")
));
assert!(matches!(
decode_edited(|b| b[18] = 7),
Err(FormatFault::Unsupported(m)) if m.contains("order")
));
assert!(matches!(
decode_edited(|b| b[GEN0 + 8] = 9),
Err(FormatFault::Unsupported(m)) if m.contains("generation state")
));
assert!(matches!(
decode_edited(|b| b[SEG0 + 12] = 2),
Err(FormatFault::Unsupported(m)) if m.contains("segment state")
));
assert!(matches!(
decode_edited(|b| b[SEG0 + 114] = 1),
Err(FormatFault::Unsupported(m)) if m.contains("location")
));
}
#[test]
fn a_manifest_that_breaks_an_invariant_is_corrupt() {
assert!(matches!(
decode_edited(|b| b[GEN0 + 8] = 1),
Err(FormatFault::Corrupt(m)) if m.contains("active")
));
assert!(matches!(
decode_edited(|b| b[GEN0 + 9] = 0),
Err(FormatFault::Corrupt(m)) if m.contains("shard")
));
assert!(matches!(
decode_edited(|b| b[SEG0 + 120 + 16..SEG0 + 120 + 24]
.copy_from_slice(&100u64.to_le_bytes())),
Err(FormatFault::Corrupt(m)) if m.contains("GSN")
));
assert!(matches!(
decode_edited(|b| {
b[SEG0 + 120 + 48..SEG0 + 120 + 56].copy_from_slice(&989u64.to_le_bytes());
b[SEG0 + 120 + 56..SEG0 + 120 + 64].copy_from_slice(&999u64.to_le_bytes());
}),
Err(FormatFault::Corrupt(m)) if m.contains("goes back")
));
assert!(matches!(
decode_edited(|b| b[40..48].copy_from_slice(&2u64.to_le_bytes())),
Err(FormatFault::Corrupt(m)) if m.contains("next_segment_id")
));
assert!(matches!(
decode_edited(|b| b[48..56].copy_from_slice(&4u64.to_le_bytes())),
Err(FormatFault::Corrupt(m)) if m.contains("next_gen_id")
));
assert!(matches!(
decode_edited(|b| b[56..64].copy_from_slice(&250u64.to_le_bytes())),
Err(FormatFault::Corrupt(m)) if m.contains("gsn_floor")
));
assert!(matches!(
decode_edited(|b| b[SEG0..SEG0 + 8].copy_from_slice(&2u64.to_le_bytes())),
Err(FormatFault::Corrupt(m)) if m.contains("segment ids")
));
assert!(matches!(
decode_edited(|b| b[16..18].copy_from_slice(&0u16.to_le_bytes())),
Err(FormatFault::Corrupt(m)) if m.contains("key")
));
}
#[test]
fn ids_are_reserved_without_changing_the_composition() {
let m = sample();
let (next, gen_id) = m.reserve_gen_id().unwrap();
assert_eq!(gen_id, 5);
assert_eq!(next.next_gen_id, 6);
assert_eq!(next.manifest_version, 10);
assert_eq!(next.generations, m.generations);
next.check().unwrap();
let (next, segment_id) = m.reserve_segment_id().unwrap();
assert_eq!(segment_id, 3);
assert_eq!(next.next_segment_id, 4);
assert_eq!(next.segments, m.segments);
next.check().unwrap();
}
#[test]
fn the_first_generation_is_added_to_an_empty_manifest() {
let (m, gen_id) = Manifest::new(32, 7, 1).reserve_gen_id().unwrap();
let m = m.with_active(active(gen_id, 1, 100)).unwrap();
assert_eq!(m.active().unwrap().gen_id, 1);
assert_eq!(m.manifest_version, 3);
m.check().unwrap();
let (m2, id2) = m.reserve_gen_id().unwrap();
assert!(m2.with_active(active(id2, 1, 100)).is_err());
}
#[test]
fn a_freeze_turns_the_active_generation_frozen() {
let (m, gen_id) = sample().reserve_gen_id().unwrap();
let m = m
.with_freeze(4_000, 400, active(gen_id, 401, 4_000))
.unwrap();
m.check().unwrap();
assert_eq!(m.frozen_count(), 2);
assert_eq!(m.oldest_frozen().unwrap().gen_id, 3);
let was_active = &m.generations[1];
assert_eq!(was_active.gen_id, 4);
assert_eq!(was_active.state, GenState::Frozen);
assert_eq!(was_active.max_gsn, 400);
assert_eq!(was_active.frozen_at_ms, 4_000);
assert_eq!(m.active().unwrap().gen_id, 5);
assert_eq!(m.gsn_floor, 400);
}
#[test]
fn a_freeze_needs_an_active_generation() {
let (m, gen_id) = Manifest::new(32, 7, 1).reserve_gen_id().unwrap();
assert!(m.with_freeze(10, 5, active(gen_id, 6, 10)).is_err());
}
#[test]
fn sealing_replaces_the_oldest_frozen_generation_with_a_segment() {
let (m, segment_id) = sample().reserve_segment_id().unwrap();
let m = m
.with_sealed(3, Some(seg(segment_id, 201, 300, 3_000)))
.unwrap();
m.check().unwrap();
assert_eq!(m.frozen_count(), 0);
assert_eq!(m.segments.len(), 3);
assert_eq!(m.segments[2].segment_id, 3);
assert_eq!(m.active().unwrap().gen_id, 4);
}
#[test]
fn sealing_a_generation_that_left_nothing_adds_no_segment() {
let mut source = sample();
source.segments.clear();
let m = source.with_sealed(3, None).unwrap();
m.check().unwrap();
assert_eq!(m.frozen_count(), 0);
assert!(m.segments.is_empty());
assert_eq!(m.gsn_floor, 300);
}
#[test]
fn only_the_oldest_frozen_generation_may_be_sealed() {
let (m, gen_id) = sample().reserve_gen_id().unwrap();
let m = m
.with_freeze(4_000, 400, active(gen_id, 401, 4_000))
.unwrap();
assert!(m.with_sealed(4, None).is_err());
assert!(m.with_sealed(3, None).is_err());
assert!(sample().with_sealed(4, None).is_err());
}
#[test]
fn retention_drops_the_oldest_segment() {
let m = sample().without_oldest_segment().unwrap();
m.check().unwrap();
assert_eq!(m.segments.len(), 1);
assert_eq!(m.segments[0].segment_id, 2);
assert_eq!(m.gsn_floor, 300, "the floor never goes down");
assert!(Manifest::new(32, 7, 1).without_oldest_segment().is_err());
}
#[test]
fn layer_times_never_go_back() {
let m = sample();
assert_eq!(m.monotone_time(10_000), 10_000);
assert_eq!(m.monotone_time(2_500), 3_000);
assert_eq!(Manifest::new(32, 7, 1).monotone_time(5), 5);
}
#[test]
fn layer_times_never_go_back_behind_the_active_generation() {
let (m, gen_id) = Manifest::new(32, 7, 1).reserve_gen_id().unwrap();
let m = m.with_active(active(gen_id, 1, 10_000)).unwrap();
assert_eq!(m.monotone_time(5_000), 10_000);
let at = m.monotone_time(5_000);
let (m, next_id) = m.reserve_gen_id().unwrap();
let m = m.with_freeze(at, 10, active(next_id, 11, at)).unwrap();
assert!(m.generations[0].opened_at_ms <= m.generations[0].frozen_at_ms);
let mut m = sample();
m.generations[1].opened_at_ms = 3_500;
m.check().unwrap();
assert_eq!(m.monotone_time(3_200), 3_500);
}
#[test]
fn a_layer_is_never_frozen_before_it_was_opened() {
let mut m = sample();
m.generations[0].opened_at_ms = 3_001;
assert!(m.check().unwrap_err().contains("opened"));
let mut m = sample();
m.segments[1].opened_at_ms = 2_001;
assert!(m.check().unwrap_err().contains("opened"));
let mut m = sample();
m.segments[1].sealed_at_ms = m.segments[1].frozen_at_ms - 1;
assert!(m.check().unwrap_err().contains("sealed at"));
let (m, gen_id) = sample().reserve_gen_id().unwrap();
let mut m = m;
m.generations[1].opened_at_ms = 5_000;
assert!(
m.with_freeze(4_000, 400, active(gen_id, 401, 5_000))
.is_err()
);
}
#[test]
fn a_gsn_above_the_sequence_range_is_refused() {
let top = SEQUENCE_MASK;
let over = SEQUENCE_MASK + 1;
let mut m = sample();
m.generations[1] = active(4, top, 3_000);
m.gsn_floor = 300;
m.check().unwrap();
let mut m = sample();
m.gsn_floor = top;
m.generations[1] = frozen(4, top, top, 3_000);
m.check().unwrap();
type Edit = (&'static str, fn(&mut Manifest, u64));
let edits: [Edit; 6] = [
("gsn_floor", |m, v| m.gsn_floor = v),
("generation min_gsn", |m, v| m.generations[1].min_gsn = v),
("generation max_gsn", |m, v| {
m.gsn_floor = v;
m.generations[0].max_gsn = v;
}),
("segment min_gsn", |m, v| {
m.segments[1].min_gsn = v;
m.segments[1].max_gsn = v;
}),
("segment max_gsn", |m, v| {
m.segments[1].max_gsn = v;
m.segments[1].entries = 1;
}),
("frozen generation min_gsn", |m, v| {
m.generations[0].min_gsn = v;
}),
];
for (what, edit) in edits {
let mut m = sample();
edit(&mut m, over);
let reason = m.check().unwrap_err();
assert!(reason.contains("sequence range"), "{what}: {reason}");
}
}
#[test]
fn a_segment_without_entries_is_refused() {
let mut m = sample();
m.segments[0].entries = 0;
assert!(m.check().unwrap_err().contains("no entries"));
assert!(matches!(
decode_edited(|b| b[SEG0 + 32..SEG0 + 40].copy_from_slice(&0u64.to_le_bytes())),
Err(FormatFault::Corrupt(m)) if m.contains("no entries")
));
}
#[test]
fn an_oversized_manifest_is_corrupt_without_being_read() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join(MANIFEST_NAME);
let file = std::fs::File::create(&path).unwrap();
file.set_len(MAX_MANIFEST_LEN + 1).unwrap();
drop(file);
match load(dir.path()).unwrap_err() {
DbError::ManifestCorrupt { path: p, reason } => {
assert_eq!(p, path);
assert!(reason.contains("larger"), "{reason}");
}
other => panic!("{other:?}"),
}
}
fn filled(segments: usize, generations: usize) -> Manifest {
let mut m = Manifest::new(32, 7, 1);
m.next_segment_id = segments as u64 + 1;
m.next_gen_id = generations as u64 + 1;
let mut gsn = 0;
for id in 1..=segments as u64 {
gsn += 1;
m.segments.push(seg(id, gsn, gsn, 1_000));
}
for id in 1..=generations as u64 {
gsn += 1;
m.generations.push(frozen(id, gsn, gsn, 1_000));
}
m.gsn_floor = gsn;
m
}
#[test]
fn the_size_bound_admits_the_largest_valid_manifest() {
let largest = filled(MAX_SEGMENTS, MAX_GENERATIONS);
largest.check().unwrap();
assert_eq!(largest.encode().len() as u64, MAX_MANIFEST_LEN);
let reason = filled(MAX_SEGMENTS + 1, 0).check().unwrap_err();
assert!(reason.contains("too many segments"), "{reason}");
let reason = filled(0, MAX_GENERATIONS + 1).check().unwrap_err();
assert!(reason.contains("too many generations"), "{reason}");
}
#[test]
fn reserved_bytes_and_mixed_orders_are_refused() {
for offset in [6, 19, GEN0 + 10, SEG0 + 115] {
assert!(
matches!(
decode_edited(|b| b[offset] = 1),
Err(FormatFault::Unsupported(_))
),
"reserved byte {offset}"
);
}
for offset in [18, SEG0 + 13] {
assert!(
matches!(
decode_edited(|b| b[offset] = 1),
Err(FormatFault::Corrupt(_))
),
"mixed order at {offset}"
);
}
assert!(matches!(
decode_edited(|b| b[SEG0 + 116] = 1),
Err(FormatFault::Corrupt(_))
));
}
#[test]
fn segment_metadata_must_match_this_manifest() {
assert!(matches!(
decode_edited(|b| b[SEG0 + 8] = 2),
Err(FormatFault::Unsupported(_))
));
assert!(matches!(
decode_edited(|b| b[SEG0 + 14] = 2),
Err(FormatFault::Unsupported(_))
));
assert!(matches!(
decode_edited(|b| b[SEG0 + 40..SEG0 + 48].copy_from_slice(&999u64.to_le_bytes())),
Err(FormatFault::Corrupt(_))
));
}
#[test]
fn sealing_cannot_substitute_an_unrelated_gsn_range() {
let (m, id) = sample().reserve_segment_id().unwrap();
assert!(m.with_sealed(3, Some(seg(id, 200, 299, 3_000))).is_err());
assert!(m.with_sealed(3, Some(seg(id, 201, 301, 3_000))).is_err());
}
fn gapped() -> (Manifest, u64) {
let mut m = sample();
m.generations = vec![frozen(3, 250, 300, 3_000), active(4, 351, 3_000)];
m.gsn_floor = 350;
m.check().unwrap();
m.reserve_segment_id().unwrap()
}
#[test]
fn sealing_is_bounded_by_the_generation_not_only_by_its_neighbours() {
let sealing_error = |m: &Manifest, segment: SegRecord| {
let err = m.with_sealed(3, Some(segment.clone())).unwrap_err();
let mut by_hand = m.clone();
by_hand.generations.remove(0);
by_hand.segments.push(segment);
by_hand.check().unwrap();
err
};
let (m, id) = gapped();
for (min_gsn, max_gsn) in [(220, 300), (250, 320)] {
let err = sealing_error(&m, seg(id, min_gsn, max_gsn, 3_000));
assert!(
matches!(err, DbError::Internal(msg) if msg.contains("generation bounds")),
"{min_gsn}..={max_gsn}: {err:?}"
);
}
m.with_sealed(3, Some(seg(id, 250, 300, 3_000))).unwrap();
}
#[test]
fn sealing_keeps_the_generation_high_water_mark_when_keys_collapse() {
let (m, id) = sample().reserve_segment_id().unwrap();
let sealed = m.with_sealed(3, Some(seg(id, 220, 280, 3_000))).unwrap();
assert_eq!(sealed.segments[2].min_gsn, 220);
assert_eq!(sealed.segments[2].max_gsn, 280);
assert_eq!(sealed.gsn_floor, 300);
sealed.check().unwrap();
}
#[test]
fn sealing_preserves_generation_open_and_freeze_times() {
let (m, id) = sample().reserve_segment_id().unwrap();
let mut segment = seg(id, 201, 300, 3_000);
segment.opened_at_ms += 1;
assert!(m.with_sealed(3, Some(segment.clone())).is_err());
segment.opened_at_ms -= 1;
segment.frozen_at_ms += 1;
assert!(m.with_sealed(3, Some(segment)).is_err());
}
#[test]
fn empty_seal_cannot_expose_an_older_segments_values() {
assert!(sample().with_sealed(3, None).is_err());
}
#[test]
fn an_empty_generation_leaves_without_a_segment_above_older_ones() {
let m = sample().with_empty_sealed(3).unwrap();
m.check().unwrap();
assert_eq!(m.frozen_count(), 0);
assert_eq!(m.segments.len(), 2);
assert_eq!(m.gsn_floor, 300);
assert!(sample().with_empty_sealed(4).is_err());
}
#[test]
fn exhausted_version_and_id_counters_return_errors() {
fn exhausted(result: DbResult<impl std::fmt::Debug>, what: &str) {
match result {
Err(DbError::Internal(msg)) => assert_eq!(msg, what),
other => panic!("expected {what:?}, got {other:?}"),
}
}
const VERSION: &str = "manifest version exhausted";
let (m, gen_id) = sample().reserve_gen_id().unwrap();
let (mut m, segment_id) = m.reserve_segment_id().unwrap();
let freeze = active(gen_id, 401, 4_000);
let sealed = seg(segment_id, 201, 300, 3_000);
m.with_freeze(4_000, 400, freeze).unwrap();
m.with_sealed(3, Some(sealed.clone())).unwrap();
m.without_oldest_segment().unwrap();
m.manifest_version = u64::MAX;
m.check().unwrap();
exhausted(m.reserve_gen_id(), VERSION);
exhausted(m.reserve_segment_id(), VERSION);
exhausted(m.with_freeze(4_000, 400, freeze), VERSION);
exhausted(m.with_sealed(3, Some(sealed)), VERSION);
exhausted(m.without_oldest_segment(), VERSION);
let (mut empty, gen_id) = Manifest::new(32, 7, 1).reserve_gen_id().unwrap();
empty.with_active(active(gen_id, 1, 100)).unwrap();
empty.manifest_version = u64::MAX;
exhausted(empty.with_active(active(gen_id, 1, 100)), VERSION);
let mut m = sample();
m.next_gen_id = u64::MAX;
m.check().unwrap();
exhausted(m.reserve_gen_id(), "generation ids exhausted");
let mut m = sample();
m.next_segment_id = u64::MAX;
m.check().unwrap();
exhausted(m.reserve_segment_id(), "segment ids exhausted");
}
#[test]
fn in_memory_manifest_obeys_the_same_v1_constraints() {
let mut m = sample();
m.order = OrderKind::ByKey;
assert!(m.check().is_err());
let mut m = sample();
m.segments[0].version = 2;
assert!(m.check().is_err());
let mut m = sample();
m.generations[1].frozen_at_ms = 1;
assert!(m.check().is_err());
let mut m = sample();
m.generations[1].min_gsn = 300;
assert!(m.check().is_err());
}
}