use std::hash::Hash;
use std::io::ErrorKind;
use std::os::unix::fs::{FileExt, MetadataExt};
use xxhash_rust::xxh3::{Xxh3, xxh3_64};
use super::FormatFault;
use super::block::{EntryIter, decode_block};
use super::core::SegCore;
use super::filter::PartitionedFilter;
use super::hash::{cmp_hk, key_hash};
use super::key_index::KeyRange;
use super::key_index::SegmentIndex;
use super::segment::Segment;
use super::sidecar::{
FILE_HEADER_LEN, OrderKind, Properties, SECTION_BLOCK_INDEX, SECTION_SEPARATOR_INDEX,
SIDX_FOOTER_LEN, SIDX_MAGIC, SegHeader, Sidecar, parse_footer, parse_index_records,
parse_table,
};
use crate::error::{DbError, DbResult};
use crate::key::Key;
use crate::sync;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VerifyProblem {
pub segment_id: u64,
pub block: Option<u32>,
pub what: String,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct VerifyReport {
pub segments: u64,
pub blocks: u64,
pub entries: u64,
pub problems: Vec<VerifyProblem>,
}
impl VerifyReport {
pub fn is_clean(&self) -> bool {
self.problems.is_empty()
}
}
struct Findings {
segment_id: u64,
problems: Vec<VerifyProblem>,
}
impl Findings {
fn push(&mut self, block: Option<u32>, what: impl Into<String>) {
self.problems.push(VerifyProblem {
segment_id: self.segment_id,
block,
what: what.into(),
});
}
}
fn describe(fault: FormatFault) -> String {
match fault {
FormatFault::Corrupt(reason) => reason,
FormatFault::Unsupported(reason) => format!("unsupported format: {reason}"),
}
}
fn recorded_entries(sidecar: &[u8]) -> Result<Vec<u32>, FormatFault> {
if sidecar.len() < FILE_HEADER_LEN + SIDX_FOOTER_LEN {
return Err(FormatFault::corrupt("sidecar has no footer"));
}
let footer_at = sidecar.len() - SIDX_FOOTER_LEN;
let (table_offset, count, table_crc) =
parse_footer(&sidecar[footer_at..], sidecar.len() as u64)?;
let records = parse_table(
&sidecar[table_offset as usize..footer_at],
count,
table_crc,
table_offset,
)?;
let index = records
.iter()
.find(|r| matches!(r.kind, SECTION_BLOCK_INDEX | SECTION_SEPARATOR_INDEX))
.ok_or_else(|| FormatFault::corrupt("sidecar has no block index section"))?;
let body = &sidecar[index.offset as usize..(index.offset + index.len) as usize];
let computed = crc32fast::hash(body);
if computed != index.crc32 {
return Err(FormatFault::corrupt(format!(
"block index section CRC mismatch: stored {:#x}, computed {computed:#x}",
index.crc32
)));
}
if index.kind == SECTION_SEPARATOR_INDEX {
let header = SegHeader::decode(&sidecar[..FILE_HEADER_LEN], SIDX_MAGIC)?;
return super::key_index::SeparatorIndex::entry_counts(body, header.key_len as usize);
}
let (records, _) = parse_index_records(body)?;
Ok(records.iter().map(|r| r.entries).collect())
}
fn read_sidecar(segment: &Segment, findings: &mut Findings) -> DbResult<Option<Vec<u8>>> {
match segment.read_original_sidecar() {
Ok(bytes) => Ok(Some(bytes)),
Err(DbError::Io(e)) if e.kind() == ErrorKind::NotFound => {
findings.push(
None,
format!("sidecar file {} is missing", segment.sidx_path().display()),
);
Ok(None)
}
Err(DbError::Io(e)) if e.kind() == ErrorKind::UnexpectedEof => {
findings.push(None, "sidecar read runs past the end of the file");
Ok(None)
}
Err(e) => Err(e),
}
}
fn check_data_file(segment: &Segment, findings: &mut Findings) -> DbResult<()> {
let held = segment.data_file().metadata()?;
let path = segment.sdat_path();
match std::fs::metadata(path) {
Ok(on_path) if (on_path.dev(), on_path.ino()) != (held.dev(), held.ino()) => {
findings.push(
None,
format!(
"data file {} is not the file this segment reads",
path.display()
),
);
}
Ok(_) => {}
Err(e) if e.kind() == ErrorKind::NotFound => {
findings.push(None, format!("data file {} is missing", path.display()));
}
Err(e) => return Err(e.into()),
}
let expected = segment.record().sdat_len;
if held.len() != expected {
findings.push(
None,
format!(
"data file is {} bytes, the manifest records {expected}",
held.len()
),
);
}
Ok(())
}
fn read_data(segment: &Segment, offset: u64, len: usize) -> DbResult<Option<Vec<u8>>> {
let mut buf = vec![0u8; len];
match segment.data_file().read_exact_at(&mut buf, offset) {
Ok(()) => Ok(Some(buf)),
Err(e) if e.kind() == ErrorKind::UnexpectedEof => Ok(None),
Err(e) => Err(e.into()),
}
}
fn check_properties(
segment: &Segment,
props: &super::sidecar::Properties,
findings: &mut Findings,
) {
let rec = segment.record();
for (field, in_props, in_record) in [
("min GSN", props.min_gsn, rec.min_gsn),
("max GSN", props.max_gsn, rec.max_gsn),
("entry count", props.entries, rec.entries),
("tombstone count", props.tombstones, rec.tombstones),
("typ_hash", props.typ_hash, rec.typ_hash),
(
"value version",
u64::from(props.value_version),
u64::from(rec.value_version),
),
("opened_at_ms", props.opened_at_ms, rec.opened_at_ms),
("frozen_at_ms", props.frozen_at_ms, rec.frozen_at_ms),
("sealed_at_ms", props.sealed_at_ms, rec.sealed_at_ms),
] {
if in_props != in_record {
findings.push(
None,
format!("properties record {field} {in_props}, the manifest records {in_record}"),
);
}
}
}
fn check_data_checksum(segment: &Segment, findings: &mut Findings) -> DbResult<()> {
let rec = segment.record();
let file = segment.data_file();
if file.metadata()?.len() != rec.sdat_len {
return Ok(());
}
let mut hasher = Xxh3::new();
let mut buf = vec![0u8; 1 << 20];
let mut offset = 0u64;
while offset < rec.sdat_len {
let n = usize::try_from(rec.sdat_len - offset).map_or(buf.len(), |n| n.min(buf.len()));
file.read_exact_at(&mut buf[..n], offset)?;
hasher.update(&buf[..n]);
offset += n as u64;
}
let checksum = hasher.digest();
if checksum != rec.sdat_checksum {
findings.push(
None,
format!(
"data file checksum {checksum:#x} differs from the manifest's {:#x}",
rec.sdat_checksum
),
);
}
Ok(())
}
struct WalkMeta<'a> {
index: &'a SegmentIndex,
filter: &'a PartitionedFilter,
prefix_filters: &'a [(u16, PartitionedFilter)],
props: &'a Properties,
key_range: Option<&'a KeyRange>,
}
pub(crate) fn verify_segment(segment: &Segment, report: &mut VerifyReport) -> DbResult<()> {
let rec = segment.record();
let mut findings = Findings {
segment_id: rec.segment_id,
problems: Vec::new(),
};
check_data_file(segment, &mut findings)?;
let mut parsed = None;
let mut recorded = None;
if let Some(sidecar) = read_sidecar(segment, &mut findings)? {
let checksum = xxh3_64(&sidecar);
if checksum != rec.sidx_checksum {
findings.push(
None,
format!(
"sidecar checksum {checksum:#x} differs from the manifest's {:#x}",
rec.sidx_checksum
),
);
}
match Sidecar::parse(&sidecar) {
Ok(metadata) => {
let header = &metadata.header;
if header.segment_id != rec.segment_id
|| header.version != rec.version
|| header.order != rec.order
|| usize::from(header.key_len) != segment.key_len()
|| header.seed != segment.seed()
{
findings.push(None, "sidecar header identity differs from this segment");
} else {
parsed = Some(metadata);
}
}
Err(fault) => findings.push(
None,
format!("sidecar cannot be parsed: {}", describe(fault)),
),
}
match recorded_entries(&sidecar) {
Ok(entries) => recorded = Some(entries),
Err(fault) => findings.push(
None,
format!("block index cannot be read: {}", describe(fault)),
),
}
}
check_properties(
segment,
parsed
.as_ref()
.map_or_else(|| segment.props(), |s| &s.props),
&mut findings,
);
let sidecar = match (&parsed, &segment.hot) {
(Some(sidecar), _) => WalkMeta {
index: &sidecar.index,
filter: &sidecar.filter,
prefix_filters: &sidecar.prefix_filters,
props: &sidecar.props,
key_range: sidecar.key_range.as_ref(),
},
(None, Some(hot)) => {
recorded = None;
WalkMeta {
index: &hot.index,
filter: &hot.filter,
prefix_filters: &hot.prefix_filters,
props: segment.props(),
key_range: segment.key_range(),
}
}
(None, None) => {
check_data_checksum(segment, &mut findings)?;
report.segments += 1;
report.problems.append(&mut findings.problems);
return Ok(());
}
};
let by_key = segment.record().order == OrderKind::ByKey;
let block_count = match sidecar.index {
SegmentIndex::Hash(index) => index.len(),
SegmentIndex::Key(index) => index.len(),
};
let mut hasher = Xxh3::new();
let mut hashed_whole_file = true;
match read_data(segment, 0, FILE_HEADER_LEN)? {
Some(header) => hasher.update(&header),
None => {
hashed_whole_file = false;
findings.push(None, "data file is shorter than its header");
}
}
let mut blocks = 0u64;
let mut entries = 0u64;
let mut tombstones = 0u64;
let mut raw_bytes = 0u64;
let mut observed_gsn: Option<(u64, u64)> = None;
let mut observed_h: Option<(u64, u64)> = None;
let mut previous: Option<(u64, Vec<u8>)> = None;
let mut observed_min_key = None;
for block in 0..block_count {
blocks += 1;
let at = Some(block as u32);
let (offset, len) = match sidecar.index {
SegmentIndex::Hash(index) => index.range(block),
SegmentIndex::Key(index) => index.range(block),
};
let Some(bytes) = read_data(segment, offset, len)? else {
hashed_whole_file = false;
findings.push(
at,
format!("block of {len} bytes at {offset} runs past the end of the file"),
);
continue;
};
hasher.update(&bytes);
let payload = match decode_block(&bytes) {
Ok(payload) => payload,
Err(fault) => {
findings.push(at, describe(fault));
continue;
}
};
raw_bytes += payload.len() as u64;
let mut in_block = 0u32;
for entry in EntryIter::new(payload, segment.key_len()) {
let entry = match entry {
Ok(entry) => entry,
Err(fault) => {
findings.push(at, describe(fault));
break;
}
};
if let Err(fault) = entry.verify_crc() {
findings.push(at, describe(fault));
}
let h = key_hash(entry.key, segment.seed());
if by_key {
if in_block == 0 {
let SegmentIndex::Key(index) = sidecar.index else {
unreachable!("parsed ByKey index")
};
let separator = index.separator(block);
if separator > entry.key
|| (block > 0
&& previous
.as_ref()
.is_some_and(|(_, pk)| pk.as_slice() >= separator))
{
findings.push(at, "separator does not separate adjacent blocks");
}
}
if matches!(sidecar.index, SegmentIndex::Key(index) if index.locate(entry.key) != block)
{
findings.push(at, "key is not routed to its block");
}
if previous
.as_ref()
.is_some_and(|(_, pk)| pk.as_slice() >= entry.key)
{
findings.push(at, "keys are out of order");
}
for (len, filter) in sidecar.prefix_filters {
if !filter
.may_contain(key_hash(&entry.key[..usize::from(*len)], segment.seed()))
{
findings.push(at, "prefix filter misses an entry");
}
}
if observed_min_key.is_none() {
observed_min_key = Some(entry.key.to_vec());
}
} else {
let SegmentIndex::Hash(index) = sidecar.index else {
unreachable!("parsed ByHash index")
};
if in_block == 0 && h != index.first_h(block) {
findings.push(
at,
format!(
"block index records first hash {:#x}, the block starts with {h:#x}",
index.first_h(block)
),
);
}
if index.locate(h) != Some(block) {
findings.push(
at,
format!("hash {h:#x} is not routed to its block {block}"),
);
}
if let Some((ph, pk)) = &previous
&& cmp_hk(*ph, pk, h, entry.key).is_ge()
{
findings.push(at, format!("entries are out of order at hash {h:#x}"));
}
}
if !sidecar.filter.may_contain(h) {
findings.push(at, format!("the filter misses hash {h:#x}"));
}
observed_h = Some(match observed_h {
Some((min, max)) => (min.min(h), max.max(h)),
None => (h, h),
});
let sequence = entry.sequence();
observed_gsn = Some(match observed_gsn {
Some((min, max)) => (min.min(sequence), max.max(sequence)),
None => (sequence, sequence),
});
if sequence < rec.min_gsn || sequence > rec.max_gsn {
findings.push(
at,
format!(
"GSN {sequence} is outside the recorded range {}..={}",
rec.min_gsn, rec.max_gsn
),
);
}
if entry.is_tombstone() {
tombstones += 1;
}
in_block += 1;
previous = Some((h, entry.key.to_vec()));
}
entries += u64::from(in_block);
if let Some(&n) = recorded.as_ref().and_then(|r| r.get(block))
&& n != in_block
{
findings.push(
at,
format!("block index records {n} entries, the block holds {in_block}"),
);
}
}
if hashed_whole_file {
let checksum = hasher.digest();
if checksum != rec.sdat_checksum {
findings.push(
None,
format!(
"data file checksum {checksum:#x} differs from the manifest's {:#x}",
rec.sdat_checksum
),
);
}
}
if entries != rec.entries {
findings.push(
None,
format!(
"{entries} entries found, the manifest records {}",
rec.entries
),
);
}
if tombstones != rec.tombstones {
findings.push(
None,
format!(
"{tombstones} tombstones found, the manifest records {}",
rec.tombstones
),
);
}
let props = sidecar.props;
if raw_bytes != props.raw_bytes {
findings.push(
None,
format!(
"{raw_bytes} payload bytes found, the properties record {}",
props.raw_bytes
),
);
}
if let Some((min_gsn, max_gsn)) = observed_gsn
&& (min_gsn != rec.min_gsn || max_gsn != rec.max_gsn)
{
findings.push(
None,
format!(
"observed GSN range {min_gsn}..={max_gsn} differs from the manifest's {}..={}",
rec.min_gsn, rec.max_gsn
),
);
}
if by_key {
if (props.min_h, props.max_h) != (0, 0) {
findings.push(None, "ByKey hash properties must be zero");
}
if let (Some(min), Some((_, max)), Some(range)) = (
observed_min_key.as_ref(),
previous.as_ref(),
sidecar.key_range,
) && (min != &range.min || max != &range.max)
{
findings.push(None, "key range differs from observed extrema");
}
} else if let Some((min_h, max_h)) = observed_h {
if min_h != props.min_h {
findings.push(
None,
format!(
"properties record min_h {:#x}, the smallest hash is {min_h:#x}",
props.min_h
),
);
}
if max_h != props.max_h {
findings.push(
None,
format!(
"properties record max_h {:#x}, the largest hash is {max_h:#x}",
props.max_h
),
);
}
}
report.segments += 1;
report.blocks += blocks;
report.entries += entries;
report.problems.append(&mut findings.problems);
Ok(())
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VerifyScope {
All,
Segment(u64),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SegmentInfo {
pub segment_id: u64,
pub version: u32,
pub entries: u64,
pub tombstones: u64,
pub min_gsn: u64,
pub max_gsn: u64,
pub frozen_at_ms: u64,
pub sealed_at_ms: u64,
pub data_bytes: u64,
pub sidecar_bytes: u64,
pub cost: u64,
pub hot: bool,
pub resident_bytes: u64,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SegStats {
pub active_keys: u64,
pub active_bytes: u64,
pub frozen_generations: usize,
pub segments: usize,
pub hot_segments: usize,
pub cold_segments: usize,
pub hot_metadata_bytes: u64,
pub skeleton_bytes: u64,
pub skeletons_pending: usize,
pub skeleton_builds_foreground: u64,
pub skeleton_build_failures: u64,
pub hot_since_ms: Option<u64>,
pub sealed_entries: u64,
pub resident_bytes: u64,
pub block_reads: u64,
pub false_positives: u64,
pub cache_hits: u64,
pub cache_misses: u64,
pub meta_cache_hits: u64,
pub meta_cache_misses: u64,
pub meta_requests: u64,
pub meta_bytes_read: u64,
}
impl<K: Key + Hash + Eq + Send + Sync + 'static> SegCore<K> {
pub(crate) fn stats(&self) -> SegStats {
metrics::gauge!("armdb.seg.block_cache_weight_bytes", "collection" => self.meta.name)
.set(self.cache.weight() as f64);
let view = self.view();
SegStats {
active_keys: view.active.keys(),
active_bytes: view.active.bytes(),
frozen_generations: view.frozen.len(),
segments: view.sealed.len(),
hot_segments: view.sealed.iter().filter(|s| s.is_hot()).count(),
cold_segments: view.sealed.iter().filter(|s| !s.is_hot()).count(),
hot_metadata_bytes: view.sealed.iter().map(|s| s.hot_bytes() as u64).sum(),
skeleton_bytes: view.sealed.iter().map(|s| s.skeleton_bytes() as u64).sum(),
skeletons_pending: view
.sealed
.iter()
.filter(|s| s.files.skeleton.is_not_ready())
.count(),
skeleton_builds_foreground: self
.shared
.foreground_builds
.load(std::sync::atomic::Ordering::Relaxed),
skeleton_build_failures: self
.shared
.build_failures
.load(std::sync::atomic::Ordering::Relaxed),
hot_since_ms: view
.sealed
.iter()
.take_while(|s| s.is_hot())
.last()
.map(|s| s.record().frozen_at_ms),
sealed_entries: view.sealed.iter().map(|s| s.record().entries).sum(),
resident_bytes: view.sealed.iter().map(|s| s.resident_bytes() as u64).sum(),
block_reads: view.sealed.iter().map(|s| s.block_reads()).sum(),
false_positives: view.sealed.iter().map(|s| s.false_positives()).sum(),
cache_hits: self.cache.hits(),
cache_misses: self.cache.misses(),
meta_cache_hits: self.cache.meta_hits(),
meta_cache_misses: self.cache.meta_misses(),
meta_requests: self.shared.io.requests(),
meta_bytes_read: self.shared.io.bytes(),
}
}
pub(crate) fn verify(&self, scope: VerifyScope) -> DbResult<VerifyReport> {
let (view, frozen_ranges, active_range) = {
let _manifest = sync::lock(&self.manifest);
let view = self.view();
let frozen = view
.frozen
.iter()
.rev()
.map(|generation| (generation.id(), generation.min_gsn(), generation.max_gsn()))
.collect::<Vec<_>>();
let active = (view.active.id(), view.active.min_gsn());
(view, frozen, active)
};
let mut report = VerifyReport::default();
let mut matched = false;
for segment in view.sealed.iter().rev() {
if let VerifyScope::Segment(id) = scope
&& segment.id() != id
{
continue;
}
matched = true;
verify_segment(segment, &mut report)?;
}
if let VerifyScope::Segment(_) = scope
&& !matched
{
return Err(DbError::Client("no sealed segment has this id"));
}
if scope == VerifyScope::All {
let mut previous_max = 0u64;
for segment in view.sealed.iter().rev() {
let rec = segment.record();
if rec.min_gsn <= previous_max {
report.problems.push(VerifyProblem {
segment_id: rec.segment_id,
block: None,
what: format!(
"GSN range starts at {}, the layer before ends at {previous_max}",
rec.min_gsn
),
});
}
previous_max = previous_max.max(rec.max_gsn);
}
for (id, min_gsn, max_gsn) in frozen_ranges {
if min_gsn <= previous_max {
report.problems.push(VerifyProblem {
segment_id: 0,
block: None,
what: format!(
"frozen generation {id} GSN range starts at {min_gsn}, the layer before ends at {previous_max}"
),
});
}
previous_max = previous_max.max(max_gsn);
}
let (id, min_gsn) = active_range;
if min_gsn <= previous_max {
report.problems.push(VerifyProblem {
segment_id: 0,
block: None,
what: format!(
"active generation {id} GSN range starts at {min_gsn}, the layer before ends at {previous_max}"
),
});
}
}
Ok(report)
}
#[cfg(test)]
pub(crate) fn verify_all(&self) -> DbResult<VerifyReport> {
self.verify(VerifyScope::All)
}
pub(crate) fn segments(&self) -> Vec<SegmentInfo> {
self.view()
.sealed
.iter()
.rev()
.map(|segment| {
let rec = segment.record();
SegmentInfo {
segment_id: rec.segment_id,
version: rec.version,
entries: rec.entries,
tombstones: rec.tombstones,
min_gsn: rec.min_gsn,
max_gsn: rec.max_gsn,
frozen_at_ms: rec.frozen_at_ms,
sealed_at_ms: rec.sealed_at_ms,
data_bytes: rec.sdat_len,
sidecar_bytes: rec.sidx_len,
cost: segment.cost(),
hot: segment.is_hot(),
resident_bytes: segment.resident_bytes() as u64,
}
})
.collect()
}
pub(crate) fn publish_gauges(&self) {
let view = self.view();
let name = self.meta.name;
let resident: usize = view.sealed.iter().map(|s| s.resident_bytes()).sum();
let false_positives: u64 = view.sealed.iter().map(|s| s.false_positives()).sum();
metrics::gauge!("armdb.seg.segments", "collection" => name).set(view.sealed.len() as f64);
metrics::gauge!("armdb.seg.frozen_generations", "collection" => name)
.set(view.frozen.len() as f64);
metrics::gauge!("armdb.seg.resident_bytes", "collection" => name).set(resident as f64);
let hot = view.sealed.iter().filter(|s| s.is_hot()).count();
let hot_bytes: usize = view.sealed.iter().map(|s| s.hot_bytes()).sum();
let skeleton_bytes: usize = view.sealed.iter().map(|s| s.skeleton_bytes()).sum();
let hot_since = view
.sealed
.iter()
.take_while(|s| s.is_hot())
.last()
.map_or(0, |s| s.record().frozen_at_ms);
metrics::gauge!("armdb.seg.hot_segments", "collection" => name).set(hot as f64);
metrics::gauge!("armdb.seg.cold_segments", "collection" => name)
.set((view.sealed.len() - hot) as f64);
metrics::gauge!("armdb.seg.hot_metadata_bytes", "collection" => name).set(hot_bytes as f64);
metrics::gauge!("armdb.seg.skeleton_bytes", "collection" => name)
.set(skeleton_bytes as f64);
metrics::gauge!("armdb.seg.hot_since_ms", "collection" => name).set(hot_since as f64);
let pending = view
.sealed
.iter()
.filter(|s| s.files.skeleton.is_not_ready())
.count();
metrics::gauge!("armdb.seg.skeletons_pending", "collection" => name).set(pending as f64);
metrics::gauge!("armdb.seg.skeleton_builds_foreground", "collection" => name).set(
self.shared
.foreground_builds
.load(std::sync::atomic::Ordering::Relaxed) as f64,
);
metrics::gauge!("armdb.seg.skeleton_build_failures", "collection" => name).set(
self.shared
.build_failures
.load(std::sync::atomic::Ordering::Relaxed) as f64,
);
metrics::gauge!("armdb.seg.meta_cache_hits", "collection" => name)
.set(self.cache.meta_hits() as f64);
metrics::gauge!("armdb.seg.meta_cache_misses", "collection" => name)
.set(self.cache.meta_misses() as f64);
metrics::gauge!("armdb.seg.meta_requests", "collection" => name)
.set(self.shared.io.requests() as f64);
metrics::gauge!("armdb.seg.meta_bytes_read", "collection" => name)
.set(self.shared.io.bytes() as f64);
metrics::gauge!("armdb.seg.active_keys", "collection" => name)
.set(view.active.keys() as f64);
metrics::gauge!("armdb.seg.filter_false_positives", "collection" => name)
.set(false_positives as f64);
metrics::gauge!("armdb.seg.block_cache_hits", "collection" => name)
.set(self.cache.hits() as f64);
metrics::gauge!("armdb.seg.block_cache_misses", "collection" => name)
.set(self.cache.misses() as f64);
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::seg::filter::PartitionedFilterBuilder;
use crate::seg::fs::real;
use crate::seg::seal::sidx_name;
use crate::seg::sidecar::{Properties, SECTION_FILTER, SECTION_PROPERTIES, encode_sidecar};
use crate::seg::testkit::{self, KEY_LEN, SEED};
fn verify(dir: &std::path::Path, rec: &crate::seg::manifest::SegRecord) -> VerifyReport {
let seg = Segment::open(
real(),
dir,
rec,
KEY_LEN as u16,
SEED,
&std::sync::Arc::new(crate::seg::core::SegShared::new()),
)
.unwrap();
let mut report = VerifyReport::default();
verify_segment(&seg, &mut report).unwrap();
report
}
fn cold_two(dir: &std::path::Path) -> std::sync::Arc<SegCore<testkit::TestKey>> {
let core = open_core(
dir,
SegConfig {
resident_metadata_bytes: Some(0),
seal_max_keys: 1_000_000,
..SegConfig::test()
},
);
for round in 0..2 {
for i in 0..200 {
core.put(&key_of(round * 1_000 + i), b"value").unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
}
assert!(core.view().sealed.iter().all(|s| !s.is_hot()));
core
}
#[test]
fn paged_statistics_are_published_as_collection_gauges() {
use crate::sync::Mutex;
use metrics::{
Counter, Gauge, GaugeFn, Histogram, Key, KeyName, Metadata, Recorder, SharedString,
Unit,
};
use std::collections::HashMap;
use std::sync::Arc;
#[derive(Default)]
struct Value(Mutex<f64>);
impl GaugeFn for Value {
fn increment(&self, n: f64) {
*crate::sync::lock(&self.0) += n;
}
fn decrement(&self, n: f64) {
*crate::sync::lock(&self.0) -= n;
}
fn set(&self, n: f64) {
*crate::sync::lock(&self.0) = n;
}
}
struct Capture {
name: &'static str,
values: Mutex<HashMap<String, Arc<Value>>>,
}
impl Recorder for Capture {
fn describe_counter(&self, _: KeyName, _: Option<Unit>, _: SharedString) {}
fn describe_gauge(&self, _: KeyName, _: Option<Unit>, _: SharedString) {}
fn describe_histogram(&self, _: KeyName, _: Option<Unit>, _: SharedString) {}
fn register_counter(&self, _: &Key, _: &Metadata<'_>) -> Counter {
Counter::noop()
}
fn register_histogram(&self, _: &Key, _: &Metadata<'_>) -> Histogram {
Histogram::noop()
}
fn register_gauge(&self, key: &Key, _: &Metadata<'_>) -> Gauge {
assert!(
key.labels()
.any(|l| l.key() == "collection" && l.value() == self.name)
);
let value = crate::sync::lock(&self.values)
.entry(key.name().to_owned())
.or_default()
.clone();
Gauge::from_arc(value)
}
}
let dir = tempfile::tempdir().unwrap();
let core = cold_two(dir.path());
core.get(&key_of(5)).unwrap().unwrap();
core.get(&key_of(5)).unwrap().unwrap();
let capture = Capture {
name: core.meta.name,
values: Mutex::default(),
};
metrics::with_local_recorder(&capture, || {
for _ in 0..2 {
let stats = core.stats();
core.publish_gauges();
for (suffix, expected) in [
("skeletons_pending", stats.skeletons_pending as u64),
(
"skeleton_builds_foreground",
stats.skeleton_builds_foreground,
),
("skeleton_build_failures", stats.skeleton_build_failures),
("meta_cache_hits", stats.meta_cache_hits),
("meta_cache_misses", stats.meta_cache_misses),
("meta_requests", stats.meta_requests),
("meta_bytes_read", stats.meta_bytes_read),
] {
let values = crate::sync::lock(&capture.values);
let value = values
.get(&format!("armdb.seg.{suffix}"))
.expect("gauge exported");
assert_eq!(*crate::sync::lock(&value.0), expected as f64, "{suffix}");
}
core.get(&key_of(1_005)).unwrap().unwrap();
}
});
}
#[test]
fn verify_reports_cold_metadata_damage_and_examines_the_rest() {
let dir = tempfile::tempdir().unwrap();
let core = cold_two(dir.path());
let view = core.view();
let older = view.sealed.iter().min_by_key(|s| s.id()).unwrap();
testkit::corrupt_section_everywhere(
older.sidx_path().parent().unwrap(),
older.record(),
SECTION_FILTER,
);
let report = core.verify(VerifyScope::All).unwrap();
assert_eq!(report.segments, 2);
assert_eq!(report.entries, 200);
assert!(!report.problems.is_empty());
assert!(report.problems.iter().all(|p| p.segment_id == older.id()));
assert!(report.problems.iter().any(|p| p.what.contains("CRC")));
}
#[test]
fn verify_reads_originals_not_cached_chunks() {
let dir = tempfile::tempdir().unwrap();
let core = cold_two(dir.path());
core.get(&key_of(1_005)).unwrap().unwrap();
let view = core.view();
let newer = view.sealed.iter().max_by_key(|s| s.id()).unwrap();
testkit::corrupt_section_everywhere(
newer.sidx_path().parent().unwrap(),
newer.record(),
SECTION_FILTER,
);
let cache_before = (core.cache.hits(), core.cache.misses());
let report = core.verify(VerifyScope::Segment(newer.id())).unwrap();
assert!(report.problems.iter().any(|p| p.what.contains("CRC")));
assert_eq!(report.blocks, 0);
assert_eq!((core.cache.hits(), core.cache.misses()), cache_before);
}
#[test]
fn verify_reports_a_page_index_that_disagrees_with_its_sections() {
let dir = tempfile::tempdir().unwrap();
let core = cold_two(dir.path());
let view = core.view();
let segment = &view.sealed[0];
testkit::rewrite_section(
segment.sidx_path().parent().unwrap(),
segment.record(),
crate::seg::sidecar::SECTION_PAGE_INDEX,
|body| body[48] ^= 1,
);
let report = core.verify(VerifyScope::Segment(segment.id())).unwrap();
assert!(
report
.problems
.iter()
.any(|p| p.what.contains("page index")),
"{:?}",
report.problems
);
assert_eq!(report.blocks, 0);
}
fn damage(segment: &Segment, data_offset: Option<u64>) {
let mut sidecar = std::fs::read(segment.sidx_path()).unwrap();
sidecar[FILE_HEADER_LEN + 1] ^= 1;
std::fs::write(segment.sidx_path(), sidecar).unwrap();
if let Some(offset) = data_offset {
let mut data = std::fs::read(segment.sdat_path()).unwrap();
data[offset as usize + 30] ^= 1;
std::fs::write(segment.sdat_path(), data).unwrap();
}
}
fn has(report: &VerifyReport, what: &str) -> bool {
report.problems.iter().any(|p| p.what.contains(what))
}
#[test]
fn a_hot_segment_with_an_unusable_sidecar_walks_its_data_from_memory() {
for damaged_data in [false, true] {
let dir = tempfile::tempdir().unwrap();
let rec = testkit::write_segment(real(), dir.path(), 1, &testkit::entries(500, 1));
let segment = open_segment(dir.path(), &rec);
assert!(segment.is_hot());
let clean = verify_open(&segment);
assert!(clean.is_clean(), "{:?}", clean.problems);
let first_block = segment.hot().index.hash_index().range(0).0;
damage(&segment, damaged_data.then_some(first_block));
let report = verify_open(&segment);
assert!(has(&report, "sidecar"), "{:?}", report.problems);
assert_eq!(report.blocks, clean.blocks, "the block walk ran");
assert_eq!(
has(&report, "data file checksum"),
damaged_data,
"{:?}",
report.problems
);
if !damaged_data {
assert_eq!(report.entries, clean.entries);
assert!(
report.problems.iter().all(|p| p.block.is_none()),
"no block defect in intact data: {:?}",
report.problems
);
}
}
}
#[test]
fn a_cold_segment_with_an_unusable_sidecar_checks_its_data_checksum() {
for damaged_data in [false, true] {
let dir = tempfile::tempdir().unwrap();
let core = cold_two(dir.path());
let view = core.view();
let segment = &view.sealed[0];
assert!(!segment.is_hot());
damage(segment, damaged_data.then_some(FILE_HEADER_LEN as u64));
let report = core.verify(VerifyScope::Segment(segment.id())).unwrap();
assert!(has(&report, "sidecar"), "{:?}", report.problems);
assert_eq!(report.blocks, 0, "no index to walk the blocks with");
assert_eq!(
has(&report, "data file checksum"),
damaged_data,
"{:?}",
report.problems
);
}
}
#[test]
fn verify_legacy_pending_and_failed_cells_remain_untouched() {
for failed in [false, true] {
let dir = tempfile::tempdir().unwrap();
testkit::build_legacy_collection(dir.path(), 1);
let core = open_core(
dir.path(),
SegConfig {
resident_metadata_bytes: Some(0),
..SegConfig::test()
},
);
let view = core.view();
let segment = &view.sealed[0];
if failed {
let original = std::fs::read(segment.sidx_path()).unwrap();
testkit::corrupt_section_everywhere(
segment.sidx_path().parent().unwrap(),
segment.record(),
SECTION_FILTER,
);
assert!(segment.skeleton().is_err());
std::fs::write(segment.sidx_path(), original).unwrap();
}
let before = core.stats();
let report = core.verify(VerifyScope::Segment(segment.id())).unwrap();
assert!(report.is_clean(), "{:?}", report.problems);
assert_eq!(report.entries, 1);
let after = core.stats();
assert_eq!(after.skeletons_pending, before.skeletons_pending);
assert_eq!(
after.skeleton_builds_foreground,
before.skeleton_builds_foreground
);
assert_eq!(
after.skeleton_build_failures,
before.skeleton_build_failures
);
assert_eq!(after.meta_requests - before.meta_requests, 1);
}
}
#[test]
fn verify_reports_a_replacement_sidecar_with_another_order() {
let dir = tempfile::tempdir().unwrap();
let replacement = tempfile::tempdir().unwrap();
let rec = testkit::write_segment(real(), dir.path(), 1, &testkit::entries(100, 1));
let segment = open_segment(dir.path(), &rec);
let clean = verify_open(&segment);
let other = testkit::write_key_segment(replacement.path(), &testkit::key_entries());
std::fs::copy(
replacement
.path()
.join(sidx_name(other.segment_id, other.version)),
segment.sidx_path(),
)
.unwrap();
let report = verify_open(&segment);
assert!(
report
.problems
.iter()
.any(|p| p.what.contains("header identity"))
);
assert_eq!(report.blocks, clean.blocks);
assert_eq!(report.entries, clean.entries);
assert!(
report.problems.iter().all(|p| p.block.is_none()),
"{:?}",
report.problems
);
}
#[test]
fn verify_propagates_original_metadata_io_errors() {
let dir = tempfile::tempdir().unwrap();
let rec = testkit::write_segment(real(), dir.path(), 1, &testkit::entries(100, 1));
let segment = open_segment(dir.path(), &rec);
segment.files.shared.io.fail_read_at(1);
let result = verify_segment(&segment, &mut VerifyReport::default());
assert!(matches!(result, Err(DbError::Io(_))));
}
#[test]
fn verify_by_key_bypasses_warm_block_cache() {
let dir = tempfile::tempdir().unwrap();
let entries = testkit::key_entries();
let rec = testkit::write_key_segment(dir.path(), &entries);
let segment = Segment::open(
real(),
dir.path(),
&rec,
KEY_LEN as u16,
SEED,
&std::sync::Arc::new(crate::seg::core::SegShared::new()),
)
.unwrap();
let cache = crate::seg::cache::SegBlockCache::new(1 << 20);
segment
.lookup(entries[0].h, &entries[0].key, &cache)
.unwrap();
let mut bytes = std::fs::read(segment.sdat_path()).unwrap();
bytes[FILE_HEADER_LEN + super::super::block::BLOCK_HEADER_LEN + 8] ^= 1;
std::fs::write(segment.sdat_path(), bytes).unwrap();
assert!(matches!(
segment
.lookup(entries[0].h, &entries[0].key, &cache)
.unwrap(),
crate::seg::segment::Lookup::Live(_)
));
let before = (cache.hits(), cache.misses());
let report = verify_open(&segment);
assert!(!report.is_clean());
assert_eq!((cache.hits(), cache.misses()), before);
assert!(report.problems.iter().any(|p| p.what.contains("CRC")));
}
#[test]
fn verify_by_key_detects_semantic_damage() {
use crate::seg::sidecar::{
SECTION_FILTER, SECTION_KEY_RANGE, SECTION_PREFIX_FILTER, SECTION_PROPERTIES,
SECTION_SEPARATOR_INDEX,
};
for (case, kind) in [
SECTION_KEY_RANGE,
SECTION_KEY_RANGE,
SECTION_FILTER,
SECTION_PREFIX_FILTER,
SECTION_SEPARATOR_INDEX,
SECTION_PROPERTIES,
]
.into_iter()
.enumerate()
{
let dir = tempfile::tempdir().unwrap();
let rec = testkit::write_legacy_key_segment(dir.path(), &testkit::key_entries());
let rec = testkit::rewrite_key_section(dir.path(), &rec, kind, |wire| match kind {
SECTION_KEY_RANGE => {
wire[if case == 0 { 31 } else { 63 }] = 1;
}
SECTION_PROPERTIES => {
wire[32] = 1;
}
SECTION_FILTER => {
*wire = super::super::filter::build_sorted_filter(&mut vec![123456]).unwrap();
}
SECTION_PREFIX_FILTER => {
wire.truncate(8);
wire.extend(
super::super::filter::build_sorted_filter(&mut vec![123456]).unwrap(),
);
}
SECTION_SEPARATOR_INDEX => {
let n = u32::from_le_bytes(wire[..4].try_into().unwrap()) as usize;
let bytes_at = 8 + (n + 1) * 8 + n * 4 + (n + 1) * 4;
wire[bytes_at + 7] = 0;
}
_ => unreachable!(),
});
let report = verify(dir.path(), &rec);
assert!(!report.is_clean(), "semantic mutation {kind} was missed");
assert!(
report
.problems
.iter()
.all(|p| !p.what.contains("checksum") && !p.what.contains("CRC")),
"{:?}",
report.problems
);
}
}
#[test]
fn statistics_count_what_reads_cost() {
let dir = tempfile::tempdir().unwrap();
let core = sealed_three(dir.path());
core.put(&key_of(9_000), b"active").unwrap();
let before = core.stats();
assert_eq!(before.segments, 3);
assert_eq!(before.sealed_entries, 600);
assert_eq!(before.active_keys, 1);
assert!(before.active_bytes > 0);
assert_eq!(before.frozen_generations, 0);
assert!(before.resident_bytes > 0);
assert_eq!(core.get(&key_of(2_005)).unwrap(), Some(b"value".to_vec()));
let cold = core.stats();
assert_eq!(cold.block_reads, before.block_reads + 1);
assert_eq!(cold.cache_misses, before.cache_misses + 1);
assert_eq!(cold.cache_hits, before.cache_hits);
assert_eq!(core.get(&key_of(2_005)).unwrap(), Some(b"value".to_vec()));
let warm = core.stats();
assert_eq!(warm.block_reads, cold.block_reads);
assert_eq!(warm.cache_misses, cold.cache_misses);
assert_eq!(warm.cache_hits, cold.cache_hits + 1);
let view = core.view();
let segment = &view.sealed[0];
let first_h = segment.hot().index.hash_index().first_h(0);
let h = (0..first_h)
.take(1_000_000)
.find(|&h| segment.hot().filter.may_contain(h))
.expect("a filter false positive below the first hash");
assert_eq!(
segment.lookup(h, &key_of(1_000_000), &core.cache).unwrap(),
crate::seg::segment::Lookup::Absent
);
let selected = core.stats();
assert_eq!(selected.false_positives, warm.false_positives + 1);
assert_eq!(selected.block_reads, warm.block_reads);
assert_eq!(selected.cache_hits, warm.cache_hits);
assert_eq!(selected.cache_misses, warm.cache_misses);
let before = selected;
for i in 50_000..50_300u64 {
assert_eq!(core.get(&key_of(i)).unwrap(), None);
}
let after = core.stats();
let probes = 300 * 3;
let false_positives = after.false_positives - before.false_positives;
assert!(
false_positives < probes / 20,
"{false_positives} of {probes}"
);
assert!(after.block_reads - before.block_reads <= false_positives);
core.get(&key_of(5)).unwrap().unwrap();
let hit = core.stats();
assert!(
hit.block_reads - after.block_reads
<= 1 + (hit.false_positives - after.false_positives)
);
}
#[test]
fn a_sound_segment_is_clean() {
let dir = tempfile::tempdir().unwrap();
let entries = testkit::entries(5_000, 1);
let rec = testkit::write_segment(real(), dir.path(), 1, &entries);
let report = verify(dir.path(), &rec);
assert!(report.is_clean(), "{:?}", report.problems);
assert_eq!(report.segments, 1);
assert_eq!(report.entries, 5_000);
assert!(report.blocks > 10);
}
#[test]
fn a_flipped_byte_is_pinned_to_its_block() {
let dir = tempfile::tempdir().unwrap();
let entries = testkit::entries(5_000, 1);
let rec = testkit::write_segment(real(), dir.path(), 1, &entries);
let seg = Segment::open(
real(),
dir.path(),
&rec,
KEY_LEN as u16,
SEED,
&std::sync::Arc::new(crate::seg::core::SegShared::new()),
)
.unwrap();
let (offset, _) = seg.hot().index.hash_index().range(3);
let mut bytes = std::fs::read(seg.sdat_path()).unwrap();
bytes[offset as usize + 30] ^= 1;
std::fs::write(seg.sdat_path(), bytes).unwrap();
let mut report = VerifyReport::default();
verify_segment(&seg, &mut report).unwrap();
assert!(!report.is_clean());
assert!(
report.problems.iter().any(|p| p.block == Some(3)),
"{:?}",
report.problems
);
assert!(
report.problems.iter().any(|p| p.what.contains("checksum")),
"{:?}",
report.problems
);
assert!(report.blocks > 10);
}
#[test]
fn a_sidecar_changed_after_open_is_reported() {
let dir = tempfile::tempdir().unwrap();
let entries = testkit::entries(1_000, 1);
let rec = testkit::write_segment(real(), dir.path(), 1, &entries);
let seg = Segment::open(
real(),
dir.path(),
&rec,
KEY_LEN as u16,
SEED,
&std::sync::Arc::new(crate::seg::core::SegShared::new()),
)
.unwrap();
let mut bytes = std::fs::read(seg.sidx_path()).unwrap();
bytes[FILE_HEADER_LEN + 2] ^= 1;
std::fs::write(seg.sidx_path(), bytes).unwrap();
let mut report = VerifyReport::default();
verify_segment(&seg, &mut report).unwrap();
assert!(
report
.problems
.iter()
.any(|p| p.what.contains("sidecar checksum")),
"{:?}",
report.problems
);
assert_eq!(report.segments, 1);
}
fn sections_of(bytes: &[u8]) -> Vec<(u32, Vec<u8>)> {
let footer_at = bytes.len() - SIDX_FOOTER_LEN;
let count = u32::from_le_bytes(bytes[footer_at..footer_at + 4].try_into().unwrap());
let table_offset =
u64::from_le_bytes(bytes[footer_at + 8..footer_at + 16].try_into().unwrap()) as usize;
(0..count as usize)
.map(|i| {
let rec = &bytes[table_offset + i * 32..table_offset + (i + 1) * 32];
let kind = u32::from_le_bytes(rec[0..4].try_into().unwrap());
let offset = u64::from_le_bytes(rec[8..16].try_into().unwrap()) as usize;
let len = u64::from_le_bytes(rec[16..24].try_into().unwrap()) as usize;
(kind, bytes[offset..offset + len].to_vec())
})
.collect()
}
fn rewrite_sidecar(
dir: &std::path::Path,
rec: &crate::seg::manifest::SegRecord,
edit: impl FnOnce(&mut Vec<(u32, Vec<u8>)>),
) -> crate::seg::manifest::SegRecord {
let path = dir.join(sidx_name(rec.segment_id, rec.version));
let mut sections = sections_of(&std::fs::read(&path).unwrap());
sections.retain(|(kind, _)| *kind != crate::seg::sidecar::SECTION_PAGE_INDEX);
edit(&mut sections);
let rebuilt = encode_sidecar(&testkit::header(rec.segment_id), §ions);
assert!(rebuilt.len() > FILE_HEADER_LEN);
std::fs::write(&path, &rebuilt).unwrap();
crate::seg::manifest::SegRecord {
sidx_len: rebuilt.len() as u64,
sidx_checksum: xxh3_64(&rebuilt),
..rec.clone()
}
}
fn section_mut(sections: &mut [(u32, Vec<u8>)], kind: u32) -> &mut Vec<u8> {
&mut sections.iter_mut().find(|(k, _)| *k == kind).unwrap().1
}
fn rewrite_props(
dir: &std::path::Path,
rec: &crate::seg::manifest::SegRecord,
edit: impl FnOnce(&mut Properties),
) -> crate::seg::manifest::SegRecord {
rewrite_sidecar(dir, rec, |sections| {
let body = section_mut(sections, SECTION_PROPERTIES);
let mut props = Properties::decode(body).unwrap();
edit(&mut props);
*body = props.encode();
})
}
#[test]
fn a_filter_that_misses_keys_is_reported() {
let dir = tempfile::tempdir().unwrap();
let entries = testkit::entries(2_000, 1);
let rec = testkit::write_segment(real(), dir.path(), 1, &entries);
let mut wrong = PartitionedFilterBuilder::new(0);
for h in 1..=2_000u64 {
wrong.push(h).unwrap();
}
let rec = rewrite_sidecar(dir.path(), &rec, |sections| {
*section_mut(sections, SECTION_FILTER) = wrong.finish().unwrap();
});
let report = verify(dir.path(), &rec);
assert!(
report.problems.iter().any(|p| p.what.contains("filter")),
"{:?}",
report.problems
);
}
#[test]
fn counts_that_disagree_with_the_record_are_reported() {
let dir = tempfile::tempdir().unwrap();
let entries = testkit::entries(1_000, 1);
let rec = testkit::write_segment(real(), dir.path(), 1, &entries);
let seg = Segment::open(
real(),
dir.path(),
&rec,
KEY_LEN as u16,
SEED,
&std::sync::Arc::new(crate::seg::core::SegShared::new()),
)
.unwrap();
let (offset, _) = seg.hot().index.hash_index().range(0);
let mut bytes = std::fs::read(seg.sdat_path()).unwrap();
bytes[offset as usize + 30] ^= 1;
std::fs::write(seg.sdat_path(), bytes).unwrap();
let mut report = VerifyReport::default();
verify_segment(&seg, &mut report).unwrap();
assert!(
report
.problems
.iter()
.any(|p| p.what.contains("entries found, the manifest records")),
"{:?}",
report.problems
);
}
#[test]
fn a_widened_gsn_range_is_reported() {
let dir = tempfile::tempdir().unwrap();
let entries = testkit::entries(1_000, 10);
let rec = testkit::write_segment(real(), dir.path(), 1, &entries);
assert_eq!((rec.min_gsn, rec.max_gsn), (10, 1_009));
let widened = crate::seg::manifest::SegRecord {
min_gsn: 9,
max_gsn: 1_010,
..rec
};
let report = verify(dir.path(), &widened);
assert!(
report.problems.iter().any(|p| p.what.contains("GSN")),
"{:?}",
report.problems
);
assert_eq!(report.entries, 1_000);
}
const SHORT_KEY: usize = 16;
fn colliding_keys(seed: u64) -> ([u8; SHORT_KEY], [u8; SHORT_KEY]) {
const SECRET_24_56: [u8; 32] = [
0x72, 0x40, 0xa4, 0xa4, 0xb7, 0xb3, 0x67, 0x1f, 0xcb, 0x79, 0xe6, 0x4e, 0xcc, 0xc0,
0xe5, 0x78, 0x82, 0x5a, 0xd0, 0x7d, 0xcc, 0xff, 0x72, 0x21, 0xb8, 0x08, 0x46, 0x74,
0xf7, 0x43, 0x24, 0x8e,
];
let word =
|i: usize| u64::from_le_bytes(SECRET_24_56[i * 8..i * 8 + 8].try_into().unwrap());
let flip1 = (word(0) ^ word(1)).wrapping_add(seed);
let flip2 = (word(2) ^ word(3)).wrapping_sub(seed);
let key = |lo: u64, hi: u64| {
let mut key = [0u8; SHORT_KEY];
key[..8].copy_from_slice(&(lo ^ flip1).to_le_bytes());
key[8..].copy_from_slice(&(hi ^ flip2).to_le_bytes());
key
};
let (a, b) = (key(0, 1 << 56), key(1, 0));
assert_ne!(a, b);
assert_eq!(
key_hash(&a, seed),
key_hash(&b, seed),
"the staged collision"
);
if a < b { (a, b) } else { (b, a) }
}
fn hand_built_segment(
dir: &std::path::Path,
blocks: &[Vec<(&[u8], u64)>],
) -> crate::seg::manifest::SegRecord {
use crate::entry::serialize_entry;
use crate::seg::block::BlockBuilder;
use crate::seg::seal::{SealedFiles, sdat_name};
use crate::seg::sidecar::{
BlockIndexBuilder, OrderKind, Properties, SDAT_MAGIC, SegHeader,
};
let header = SegHeader {
segment_id: 1,
version: 1,
order: OrderKind::ByHash,
key_len: SHORT_KEY as u16,
seed: SEED,
block_size: 4 * 1024,
};
let mut sdat = header.encode(SDAT_MAGIC).to_vec();
let mut index = BlockIndexBuilder::new();
let mut filter = PartitionedFilterBuilder::new(0);
let (mut entries, mut raw_bytes) = (0u64, 0u64);
let mut hashes = Vec::new();
for block in blocks {
let mut builder = BlockBuilder::new(u32::MAX);
for &(key, gsn) in block {
let h = key_hash(key, SEED);
builder
.push(h, &serialize_entry(gsn, key, b"v", false))
.unwrap();
filter.push(h).unwrap();
hashes.push(h);
entries += 1;
}
let finished = builder.finish();
index.push(finished.first_h, finished.len() as u32, finished.entries);
raw_bytes += finished.payload.len() as u64;
sdat.extend_from_slice(&finished.header);
sdat.extend_from_slice(&finished.payload);
}
let gsns = blocks.iter().flatten().map(|&(_, gsn)| gsn);
let props = Properties {
entries,
tombstones: 0,
min_gsn: gsns.clone().min().unwrap(),
max_gsn: gsns.max().unwrap(),
min_h: hashes[0],
max_h: *hashes.last().unwrap(),
raw_bytes,
opened_at_ms: 1_000,
frozen_at_ms: 2_000,
sealed_at_ms: 3_000,
typ_hash: 0xcafe,
value_version: 3,
writer: "hand".into(),
};
let sidx = encode_sidecar(
&header,
&[
(crate::seg::sidecar::SECTION_BLOCK_INDEX, index.finish()),
(SECTION_FILTER, filter.finish().unwrap()),
(SECTION_PROPERTIES, props.encode()),
],
);
std::fs::write(dir.join(sdat_name(1, 1)), &sdat).unwrap();
std::fs::write(dir.join(sidx_name(1, 1)), &sidx).unwrap();
SealedFiles {
header,
sdat_len: sdat.len() as u64,
sdat_checksum: xxh3_64(&sdat),
sidx_len: sidx.len() as u64,
sidx_checksum: xxh3_64(&sidx),
props,
}
.into_record()
}
fn verify_short(dir: &std::path::Path, rec: &crate::seg::manifest::SegRecord) -> VerifyReport {
let seg = Segment::open(
real(),
dir,
rec,
SHORT_KEY as u16,
SEED,
&std::sync::Arc::new(crate::seg::core::SegShared::new()),
)
.unwrap();
let mut report = VerifyReport::default();
verify_segment(&seg, &mut report).unwrap();
report
}
#[test]
fn an_equal_hash_run_across_a_block_boundary_is_reported() {
let (k1, k2) = colliding_keys(SEED);
let x = key_hash(&k1, SEED);
let lower = (0u64..)
.map(|i| {
let mut key = [0u8; SHORT_KEY];
key[..8].copy_from_slice(&i.to_le_bytes());
key
})
.find(|key| key_hash(key, SEED) < x)
.unwrap();
let dir = tempfile::tempdir().unwrap();
let rec = hand_built_segment(dir.path(), &[vec![(&lower, 1), (&k1, 2), (&k2, 3)]]);
let report = verify_short(dir.path(), &rec);
assert!(report.is_clean(), "{:?}", report.problems);
let dir = tempfile::tempdir().unwrap();
let rec = hand_built_segment(dir.path(), &[vec![(&lower, 1), (&k1, 2)], vec![(&k2, 3)]]);
let report = verify_short(dir.path(), &rec);
assert_eq!(report.problems.len(), 1, "{:?}", report.problems);
let problem = &report.problems[0];
assert_eq!(problem.block, Some(0));
assert!(
problem.what.contains("is not routed to its block"),
"{problem:?}"
);
}
#[test]
fn a_narrowed_gsn_range_is_reported() {
let dir = tempfile::tempdir().unwrap();
let entries = testkit::entries(1_000, 1);
let rec = testkit::write_segment(real(), dir.path(), 1, &entries);
let narrowed = crate::seg::manifest::SegRecord {
min_gsn: rec.min_gsn + 5,
..rec
};
let report = verify(dir.path(), &narrowed);
assert!(
report.problems.iter().any(|p| p.what.contains("GSN")),
"{:?}",
report.problems
);
}
fn assert_one_problem(report: &VerifyReport, needle: &str) {
assert_eq!(report.problems.len(), 1, "{:?}", report.problems);
assert!(
report.problems[0].what.contains(needle),
"{:?}",
report.problems
);
}
#[test]
fn properties_that_disagree_with_the_record_are_reported() {
type Rec = crate::seg::manifest::SegRecord;
let dir = tempfile::tempdir().unwrap();
let rec = testkit::write_segment(real(), dir.path(), 1, &testkit::entries(500, 1));
type Case = (&'static str, fn(&mut Rec));
let cases: [Case; 5] = [
("typ_hash", |r| r.typ_hash ^= 1),
("value version", |r| r.value_version += 1),
("opened_at_ms", |r| r.opened_at_ms += 1),
("frozen_at_ms", |r| r.frozen_at_ms += 1),
("sealed_at_ms", |r| r.sealed_at_ms += 1),
];
for (field, edit) in cases {
let mut changed = rec.clone();
edit(&mut changed);
let report = verify(dir.path(), &changed);
assert_one_problem(&report, &format!("properties record {field}"));
}
}
#[test]
fn a_gsn_range_in_the_properties_that_disagrees_is_reported() {
let dir = tempfile::tempdir().unwrap();
let rec = testkit::write_segment(real(), dir.path(), 1, &testkit::entries(500, 1));
let rec = rewrite_props(dir.path(), &rec, |p| p.min_gsn += 1);
assert_one_problem(&verify(dir.path(), &rec), "properties record min GSN");
let rec = rewrite_props(dir.path(), &rec, |p| {
p.min_gsn -= 1;
p.max_gsn += 1;
});
assert_one_problem(&verify(dir.path(), &rec), "properties record max GSN");
}
#[test]
fn a_hash_range_that_disagrees_with_the_entries_is_reported() {
let dir = tempfile::tempdir().unwrap();
let rec = testkit::write_segment(real(), dir.path(), 1, &testkit::entries(500, 1));
let rec = rewrite_props(dir.path(), &rec, |p| p.min_h += 1);
assert_one_problem(&verify(dir.path(), &rec), "properties record min_h");
let rec = rewrite_props(dir.path(), &rec, |p| {
p.min_h -= 1;
p.max_h -= 1;
});
assert_one_problem(&verify(dir.path(), &rec), "properties record max_h");
}
fn open_segment(dir: &std::path::Path, rec: &crate::seg::manifest::SegRecord) -> Segment {
Segment::open(
real(),
dir,
rec,
KEY_LEN as u16,
SEED,
&std::sync::Arc::new(crate::seg::core::SegShared::new()),
)
.unwrap()
}
fn verify_open(seg: &Segment) -> VerifyReport {
let mut report = VerifyReport::default();
verify_segment(seg, &mut report).unwrap();
report
}
#[test]
fn a_data_file_removed_after_open_is_a_problem_not_an_error() {
let dir = tempfile::tempdir().unwrap();
let rec = testkit::write_segment(real(), dir.path(), 1, &testkit::entries(1_000, 1));
let seg = open_segment(dir.path(), &rec);
std::fs::remove_file(seg.sdat_path()).unwrap();
let report = verify_open(&seg);
assert_one_problem(&report, "is missing");
assert!(report.problems[0].what.contains("data file"));
assert_eq!(report.segments, 1);
assert_eq!(report.entries, 1_000);
}
#[test]
fn a_sidecar_removed_after_open_is_a_problem_not_an_error() {
let dir = tempfile::tempdir().unwrap();
let rec = testkit::write_segment(real(), dir.path(), 1, &testkit::entries(1_000, 1));
let seg = open_segment(dir.path(), &rec);
std::fs::remove_file(seg.sidx_path()).unwrap();
let report = verify_open(&seg);
assert_one_problem(&report, "is missing");
assert!(report.problems[0].what.contains("sidecar file"));
assert_eq!(report.segments, 1);
assert_eq!(report.entries, 1_000);
assert!(report.blocks > 0);
}
#[test]
fn a_data_file_replaced_after_open_is_reported() {
let dir = tempfile::tempdir().unwrap();
let rec = testkit::write_segment(real(), dir.path(), 1, &testkit::entries(1_000, 1));
let seg = open_segment(dir.path(), &rec);
let copy = dir.path().join("copy");
std::fs::copy(seg.sdat_path(), ©).unwrap();
std::fs::rename(©, seg.sdat_path()).unwrap();
assert_one_problem(&verify_open(&seg), "is not the file this segment reads");
}
#[test]
fn a_truncated_data_file_is_reported() {
let dir = tempfile::tempdir().unwrap();
let rec = testkit::write_segment(real(), dir.path(), 1, &testkit::entries(1_000, 1));
let seg = open_segment(dir.path(), &rec);
let last = seg.hot().index.hash_index().len() - 1;
std::fs::OpenOptions::new()
.write(true)
.open(seg.sdat_path())
.unwrap()
.set_len(rec.sdat_len - 10)
.unwrap();
let report = verify_open(&seg);
assert!(
report
.problems
.iter()
.any(|p| p.block.is_none() && p.what.contains("bytes, the manifest records")),
"{:?}",
report.problems
);
assert!(
report
.problems
.iter()
.any(|p| p.block == Some(last as u32) && p.what.contains("past the end")),
"{:?}",
report.problems
);
assert!(
report.problems.iter().all(|p| !p.what.contains("checksum")),
"{:?}",
report.problems
);
}
#[test]
fn a_block_index_section_that_fails_its_crc_is_reported() {
let dir = tempfile::tempdir().unwrap();
let rec = testkit::write_segment(real(), dir.path(), 1, &testkit::entries(1_000, 1));
let seg = open_segment(dir.path(), &rec);
let mut bytes = std::fs::read(seg.sidx_path()).unwrap();
bytes[FILE_HEADER_LEN + 20] ^= 1;
std::fs::write(seg.sidx_path(), bytes).unwrap();
let report = verify_open(&seg);
assert!(
report
.problems
.iter()
.any(|p| p.what.contains("block index section CRC mismatch")),
"{:?}",
report.problems
);
assert!(
report
.problems
.iter()
.all(|p| !p.what.contains("entries, the block holds")),
"{:?}",
report.problems
);
}
#[test]
fn a_sidecar_with_fewer_blocks_than_the_segment_is_reported() {
use crate::seg::sidecar::{BlockIndexBuilder, SECTION_BLOCK_INDEX};
let dir = tempfile::tempdir().unwrap();
let rec = testkit::write_segment(real(), dir.path(), 1, &testkit::entries(1_000, 1));
let seg = open_segment(dir.path(), &rec);
let blocks = seg.hot().index.hash_index().len();
rewrite_sidecar(dir.path(), &rec, |sections| {
let body = section_mut(sections, SECTION_BLOCK_INDEX);
let (records, _) = parse_index_records(body).unwrap();
let mut shorter = BlockIndexBuilder::new();
for r in &records[..records.len() - 1] {
shorter.push(r.first_h, r.block_len, r.entries);
}
*body = shorter.finish();
});
let report = verify_open(&seg);
assert_eq!(report.blocks, (blocks - 1) as u64);
assert!(report.entries < rec.entries);
assert!(
report
.problems
.iter()
.any(|p| p.what.contains("sidecar checksum")),
"{:?}",
report.problems
);
assert!(
report
.problems
.iter()
.any(|p| p.what.contains("entries found, the manifest records")),
"{:?}",
report.problems
);
}
use crate::error::DbError;
use crate::seg::config::SegConfig;
use crate::seg::testkit::{key_of, open_core};
fn sealed_three(
dir: &std::path::Path,
) -> std::sync::Arc<crate::seg::core::SegCore<crate::seg::testkit::TestKey>> {
let config = SegConfig {
seal_max_keys: 1_000_000,
max_frozen_generations: 8,
..SegConfig::test()
};
let core = open_core(dir, config);
for round in 0..3u64 {
for i in 0..200 {
core.put(&key_of(round * 1_000 + i), b"value").unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
}
core
}
#[test]
fn a_sound_collection_is_clean() {
let dir = tempfile::tempdir().unwrap();
let core = sealed_three(dir.path());
let report = core.verify_all().unwrap();
assert!(report.is_clean(), "{:?}", report.problems);
assert_eq!(report.segments, 3);
assert_eq!(report.entries, 600);
let one = core.verify(VerifyScope::Segment(2)).unwrap();
assert_eq!(one.segments, 1);
assert_eq!(one.entries, 200);
}
#[test]
fn an_unknown_segment_is_a_client_error() {
let dir = tempfile::tempdir().unwrap();
let core = sealed_three(dir.path());
assert!(matches!(
core.verify(VerifyScope::Segment(99)),
Err(DbError::Client(_))
));
}
#[test]
fn damage_in_one_segment_does_not_hide_the_others() {
let dir = tempfile::tempdir().unwrap();
let core = sealed_three(dir.path());
let middle = core.view().sealed[1].clone();
let (offset, _) = middle.hot().index.hash_index().range(0);
let mut bytes = std::fs::read(middle.sdat_path()).unwrap();
bytes[offset as usize + 30] ^= 1;
std::fs::write(middle.sdat_path(), bytes).unwrap();
let report = core.verify_all().unwrap();
assert_eq!(report.segments, 3, "every segment was checked");
assert!(!report.is_clean());
assert!(report.problems.iter().all(|p| p.segment_id == middle.id()));
}
#[test]
fn segments_are_listed_oldest_first() {
let dir = tempfile::tempdir().unwrap();
let core = sealed_three(dir.path());
let info = core.segments();
assert_eq!(
info.iter().map(|s| s.segment_id).collect::<Vec<_>>(),
[1, 2, 3]
);
assert_eq!(info[0].entries, 200);
assert_eq!(info[0].min_gsn, 1);
assert_eq!(info[0].max_gsn, 200);
assert_eq!(info[1].min_gsn, 201);
assert!(info[0].data_bytes > 0 && info[0].sidecar_bytes > 0);
assert!(info[0].resident_bytes > 0);
assert!(info[0].resident_bytes < info[0].data_bytes);
core.publish_gauges();
}
#[test]
fn overlapping_frozen_and_active_layers_are_reported() {
use crate::seg::core::View;
use crate::sync;
for overlap_active in [false, true] {
let dir = tempfile::tempdir().unwrap();
let core = open_core(
dir.path(),
SegConfig {
max_frozen_generations: 8,
..SegConfig::test()
},
);
core.put(&key_of(1), b"one").unwrap();
core.seal().unwrap();
core.put(&key_of(2), b"two").unwrap();
core.seal().unwrap();
assert!(core.verify_all().unwrap().is_clean());
let view = core.view();
let affected_id;
{
let _manifest = sync::lock(&core.manifest);
let mut frozen = view.frozen.clone();
let active = if overlap_active {
affected_id = frozen[0].id();
frozen[0].clone()
} else {
frozen.reverse();
affected_id = frozen[0].id();
view.active.clone()
};
core.set_view(View {
active,
frozen,
sealed: view.sealed.clone(),
});
}
let report = core.verify_all().unwrap();
assert!(!report.is_clean());
assert!(
report.problems.iter().any(|problem| problem.segment_id == 0
&& problem.block.is_none()
&& problem
.what
.contains(&format!("generation {affected_id} GSN range"))),
"{:?}",
report.problems
);
let _manifest = sync::lock(&core.manifest);
core.set_view(View {
active: view.active.clone(),
frozen: view.frozen.clone(),
sealed: view.sealed.clone(),
});
}
}
}