use std::collections::HashSet;
use std::fs::File;
use std::hash::{BuildHasher, Hash, Hasher};
use std::io::Write;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::time::{SystemTime, UNIX_EPOCH};
use super::cache::SegBlockCache;
use super::config::SegConfig;
use super::fs::{SegFs, real};
use super::generation::{CollectionFence, GEN_DIR, GenLookup, GenProbe, Generation, gen_dir_name};
use super::hash::key_hash;
use super::manifest::{
self, GenRecord, GenState, MANIFEST_NAME, MANIFEST_TMP, Manifest, PublishError,
};
use super::seal::{SEG_DIR, sdat_name, sidx_name};
use super::segment::{Lookup, Segment};
use super::sidecar::OrderKind;
use crate::error::{DbError, DbResult};
use crate::key::Key;
use crate::meta::{Backend, DbMeta, META_VERSION};
use crate::sync::{self, Condvar, Mutex, RwLock};
const ROOT_META: &str = "db.meta";
const ROOT_META_TMP: &str = "db.meta.tmp";
const SEGMENT_LOAD_THREADS: usize = 8;
pub(crate) type Clock = Arc<dyn Fn() -> u64 + Send + Sync>;
pub(crate) fn wall_clock() -> Clock {
Arc::new(|| {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_millis() as u64)
.unwrap_or(0)
})
}
#[derive(Debug, Clone, Copy)]
pub struct SegMeta {
pub name: &'static str,
pub typ_hash: u64,
pub value_version: u16,
}
pub(crate) struct OpenOptions {
pub fs: Arc<dyn SegFs>,
pub clock: Clock,
pub worker: bool,
}
impl OpenOptions {
pub(crate) fn production() -> Self {
Self {
fs: real(),
clock: wall_clock(),
worker: true,
}
}
}
pub(crate) struct View<K: Key + Hash + Eq + Send + Sync> {
pub active: Arc<Generation<K>>,
pub frozen: Vec<Arc<Generation<K>>>,
pub sealed: Vec<Arc<Segment>>,
}
#[derive(Debug, Clone, Default)]
pub(crate) struct SealState {
pub in_flight: Option<u64>,
pub last_error: Option<String>,
pub retry_at_ms: Option<u64>,
pub last_sealed_at_ms: Option<u64>,
pub failures: u64,
}
pub(crate) struct SegShared {
pub(crate) io: super::page_index::MetaIo,
pub(crate) slots: super::skeleton::BuildSlots,
pub(crate) foreground_builds: AtomicU64,
pub(crate) build_failures: AtomicU64,
#[cfg(test)]
pub(crate) built: Mutex<Vec<u64>>,
}
impl SegShared {
pub(crate) fn new() -> Self {
Self {
io: super::page_index::MetaIo::new(),
slots: super::skeleton::BuildSlots::new(2),
foreground_builds: AtomicU64::new(0),
build_failures: AtomicU64::new(0),
#[cfg(test)]
built: Mutex::new(Vec::new()),
}
}
}
pub(crate) struct SegCore<K: Key + Hash + Eq + Send + Sync> {
pub(crate) meta: SegMeta,
pub(crate) dir: PathBuf,
pub(crate) gen_root: PathBuf,
pub(crate) seg_root: PathBuf,
pub(crate) config: SegConfig,
pub(crate) order: OrderKind,
pub(crate) prefix_filters: Vec<usize>,
pub(crate) fs: Arc<dyn SegFs>,
pub(crate) clock: Clock,
pub(crate) seed: u64,
view: RwLock<Arc<View<K>>>,
pub(crate) manifest: Mutex<Manifest>,
pub(crate) cache: SegBlockCache,
pub(crate) shared: Arc<SegShared>,
pub(crate) collection_fence: Arc<CollectionFence>,
pub(crate) shut_down: AtomicBool,
pub(crate) seal: Mutex<SealState>,
pub(crate) seal_attempt: Mutex<()>,
pub(crate) seal_cv: Condvar,
pub(crate) signal: Arc<WorkerSignal>,
pub(crate) worker: Mutex<Option<std::thread::JoinHandle<()>>>,
pub(crate) last_tick_ms: AtomicU64,
_lease: File,
}
#[derive(Default)]
struct WorkerFlags {
wake: bool,
stop: bool,
}
pub(crate) struct WorkerSignal {
flags: Mutex<WorkerFlags>,
cv: Condvar,
}
impl WorkerSignal {
fn new() -> Self {
Self {
flags: Mutex::new(WorkerFlags::default()),
cv: Condvar::new(),
}
}
pub(crate) fn wake(&self) {
sync::lock(&self.flags).wake = true;
self.cv.notify_all();
}
pub(crate) fn stop(&self) {
sync::lock(&self.flags).stop = true;
self.cv.notify_all();
}
pub(crate) fn wait(&self, pause: std::time::Duration) -> bool {
let mut flags = sync::lock(&self.flags);
if !flags.stop && !flags.wake && !pause.is_zero() {
flags = sync::cv_wait_timeout(&self.cv, &self.flags, flags, pause);
}
flags.wake = false;
flags.stop
}
}
fn random_seed() -> u64 {
let mut hasher = std::collections::hash_map::RandomState::new().build_hasher();
hasher.write_u128(
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0),
);
hasher.finish()
}
fn holds_anything(dir: &Path) -> DbResult<bool> {
match std::fs::read_dir(dir) {
Ok(mut entries) => Ok(entries.next().is_some()),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(false),
Err(e) => Err(e.into()),
}
}
pub(crate) fn validate_prefix_filters<K: Key>(lengths: &[usize]) -> DbResult<()> {
let mut seen = HashSet::new();
for &length in lengths {
if length == 0 || length >= size_of::<K>() || !seen.insert(length) {
return Err(DbError::Config(
"prefix filter lengths must be distinct interior key positions",
));
}
if let armour_core::KeyScheme::Typed(parts) = K::KEY_SCHEME {
let mut end = 0;
if !parts.iter().any(|part| {
end += part.byte_len();
end == length
}) {
return Err(DbError::Config(
"a typed prefix filter must end on a field boundary",
));
}
}
}
Ok(())
}
fn check_root_meta(dir: &Path, required: bool) -> DbResult<()> {
let path = dir.join(ROOT_META);
let bytes = match std::fs::read(&path) {
Ok(bytes) => bytes,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
return if required {
Err(DbError::FormatMismatch(format!(
"{}: db.meta is missing",
dir.display()
)))
} else {
Ok(())
};
}
Err(e) => return Err(e.into()),
};
let meta = DbMeta::decode(&bytes)?;
if meta.backend != Backend::Segmented {
return Err(DbError::FormatMismatch(format!(
"{}: db.meta names backend {:?}, not a segmented collection",
dir.display(),
meta.backend
)));
}
Ok(())
}
pub(crate) fn create_layout(fs: &dyn SegFs, dir: &Path) -> DbResult<()> {
fs.create_dir_all(dir)?;
fs.create_dir_all(&dir.join(GEN_DIR))?;
fs.create_dir_all(&dir.join(SEG_DIR))?;
let meta = DbMeta {
version: META_VERSION,
backend: Backend::Segmented,
shard_count: 0,
shard_prefix_bits: 0,
flags: 0,
};
let tmp = dir.join(ROOT_META_TMP);
let mut file = fs.create(&tmp)?;
file.write_all(&meta.encode())?;
fs.sync_file(&file, &tmp)?;
drop(file);
fs.rename(&tmp, &dir.join(ROOT_META))?;
fs.sync_dir(dir)?;
super::failpoint!(LAYOUT_CREATED);
Ok(())
}
fn remove_garbage(
fs: &dyn SegFs,
dir: &Path,
gen_root: &Path,
seg_root: &Path,
manifest: &Manifest,
) -> DbResult<()> {
fs.remove_file(&dir.join(MANIFEST_TMP))?;
fs.remove_file(&dir.join(ROOT_META_TMP))?;
let generations: HashSet<String> = manifest
.generations
.iter()
.map(|g| gen_dir_name(g.gen_id))
.collect();
let mut removed = 0usize;
if gen_root.is_dir() {
for entry in std::fs::read_dir(gen_root)? {
let entry = entry?;
if generations.contains(entry.file_name().to_string_lossy().as_ref()) {
continue;
}
let path = entry.path();
tracing::info!(path = %path.display(), "removing a generation the manifest does not mention");
if path.is_dir() {
fs.remove_dir_all(&path)?;
} else {
fs.remove_file(&path)?;
}
removed += 1;
}
fs.sync_dir(gen_root)?;
}
let segments: HashSet<String> = manifest
.segments
.iter()
.flat_map(|s| {
[
sdat_name(s.segment_id, s.version),
sidx_name(s.segment_id, s.version),
]
})
.collect();
if seg_root.is_dir() {
for entry in std::fs::read_dir(seg_root)? {
let entry = entry?;
if segments.contains(entry.file_name().to_string_lossy().as_ref()) {
continue;
}
let path = entry.path();
tracing::info!(path = %path.display(), "removing a segment file the manifest does not mention");
if path.is_dir() {
fs.remove_dir_all(&path)?;
} else {
fs.remove_file(&path)?;
}
removed += 1;
}
fs.sync_dir(seg_root)?;
}
if removed > 0 {
metrics::counter!("armdb.seg.garbage_removed").increment(removed as u64);
}
Ok(())
}
fn join_preparations<T>(
handles: Vec<std::thread::ScopedJoinHandle<'_, DbResult<T>>>,
) -> DbResult<Vec<T>> {
let results = handles
.into_iter()
.map(|h| h.join().unwrap_or(Err(DbError::RecoveryPanic)))
.collect::<Vec<_>>();
results.into_iter().collect()
}
fn load_segments(
fs: &Arc<dyn SegFs>,
seg_root: &Path,
manifest: &Manifest,
shared: &Arc<SegShared>,
budget: Option<u64>,
) -> DbResult<Vec<Arc<Segment>>> {
let mut records: Vec<_> = manifest.segments.iter().collect();
records.sort_by_key(|rec| std::cmp::Reverse((rec.frozen_at_ms, rec.segment_id)));
let mut loaded = Vec::with_capacity(records.len());
let mut remaining = budget;
let mut prefix_closed = false;
for batch in records.chunks(SEGMENT_LOAD_THREADS) {
let checked = std::thread::scope(|scope| {
let handles: Vec<_> = batch
.iter()
.map(|rec| {
scope.spawn(move || {
Segment::check_files(seg_root, rec, manifest.key_len, manifest.seed, shared)
})
})
.collect();
join_preparations(handles)
})?;
let inputs: Vec<_> = batch
.iter()
.zip(checked)
.map(|(rec, checked)| {
let hot = if prefix_closed {
false
} else if let Some(left) = remaining {
if let Some(next) = left.checked_sub(checked.cost) {
remaining = Some(next);
true
} else {
prefix_closed = true;
false
}
} else {
true
};
(rec, checked, hot)
})
.collect();
let results = std::thread::scope(|scope| {
let handles: Vec<_> = inputs
.into_iter()
.map(|(rec, checked, hot)| {
let fs = fs.clone();
scope.spawn(move || {
if hot {
Segment::open_hot_checked(fs, seg_root, rec, shared, checked)
} else {
Segment::open_cold(fs, seg_root, rec, shared, checked)
}
})
})
.collect();
handles
.into_iter()
.map(|h| h.join().unwrap_or(Err(DbError::RecoveryPanic)))
.collect::<Vec<_>>()
});
for result in results {
loaded.push(Arc::new(result?));
}
}
Ok(loaded)
}
impl<K: Key + Hash + Eq + Send + Sync + 'static> SegCore<K> {
pub(crate) fn open_deferred(
dir: &Path,
meta: SegMeta,
config: SegConfig,
mut options: OpenOptions,
) -> DbResult<Arc<Self>> {
options.worker = false;
Self::open(dir, meta, config, options)
}
pub(crate) fn start_background(self: &Arc<Self>) -> DbResult<()> {
self.start_worker()
}
pub(crate) fn open(
dir: &Path,
meta: SegMeta,
config: SegConfig,
options: OpenOptions,
) -> DbResult<Arc<Self>> {
Self::open_mode(dir, meta, config, options, OrderKind::ByHash, &[])
}
#[allow(dead_code)] pub(crate) fn open_tree(
dir: &Path,
meta: SegMeta,
prefix_filters: &'static [usize],
config: SegConfig,
options: OpenOptions,
) -> DbResult<Arc<Self>> {
Self::open_mode(dir, meta, config, options, OrderKind::ByKey, prefix_filters)
}
#[allow(dead_code)] pub(crate) fn open_tree_deferred(
dir: &Path,
meta: SegMeta,
prefix_filters: &'static [usize],
config: SegConfig,
mut options: OpenOptions,
) -> DbResult<Arc<Self>> {
options.worker = false;
Self::open_tree(dir, meta, prefix_filters, config, options)
}
fn open_mode(
dir: &Path,
meta: SegMeta,
config: SegConfig,
options: OpenOptions,
order: OrderKind,
prefix_filters: &[usize],
) -> DbResult<Arc<Self>> {
config.validate()?;
validate_prefix_filters::<K>(prefix_filters)?;
let key_len = u16::try_from(size_of::<K>())
.ok()
.filter(|&len| len > 0)
.ok_or(DbError::Config(
"a segmented key must be 1 to 65535 bytes long",
))?;
let OpenOptions { fs, clock, worker } = options;
let gen_root = dir.join(GEN_DIR);
let seg_root = dir.join(SEG_DIR);
fs.create_dir_all(dir)?;
let lease = crate::lock::acquire(dir)?;
let mut manifest = match manifest::load(dir)? {
Some(manifest) => {
check_root_meta(dir, true)?;
if manifest.order != order {
return Err(DbError::FormatMismatch(format!(
"{}: collection order {:?} differs from requested {:?}",
dir.display(),
manifest.order,
order
)));
}
manifest
}
None => {
check_root_meta(dir, false)?;
if holds_anything(&gen_root)? || holds_anything(&seg_root)? {
return Err(DbError::ManifestCorrupt {
path: dir.join(MANIFEST_NAME),
reason: "the manifest is missing while gen/ or seg/ holds data".into(),
});
}
create_layout(&*fs, dir)?;
let mut manifest = Manifest::new(key_len, random_seed(), clock());
manifest.order = order;
manifest::publish(&*fs, dir, &manifest).map_err(PublishError::into_inner)?;
super::failpoint!(FIRST_MANIFEST_PUBLISHED);
manifest
}
};
if manifest.key_len != key_len {
return Err(DbError::FormatMismatch(format!(
"{}: the collection has key length {}, the type has {key_len}",
dir.display(),
manifest.key_len
)));
}
let seed = manifest.seed;
let collection_fence = Arc::new(CollectionFence::new(meta.name));
let shared = Arc::new(SegShared::new());
let sealed = load_segments(
&fs,
&seg_root,
&manifest,
&shared,
config.resident_metadata_bytes,
)?;
for rec in &manifest.generations {
Generation::<K>::check_existing(&gen_root, rec)?;
}
fs.sync_dir(dir)?;
let mut generations = Vec::with_capacity(manifest.generations.len());
for rec in &manifest.generations {
let mut generation =
Generation::<K>::open_existing(fs.clone(), &gen_root, rec, &config, order)?;
generation.bind_fence(collection_fence.clone());
generations.push(Arc::new(generation));
}
remove_garbage(&*fs, dir, &gen_root, &seg_root, &manifest)?;
let recovered = generations
.iter()
.map(|g| g.next_gsn() - 1)
.max()
.unwrap_or(0);
let next_gsn = manifest
.gsn_floor
.max(recovered)
.checked_add(1)
.ok_or(DbError::Internal("segmented GSN exhausted"))?;
let active = if manifest.active().is_some() {
let active = generations
.pop()
.expect("the active generation is the newest");
active.raise_gsn(next_gsn);
active
} else {
let mut generation = Self::create_first_generation(
&fs,
dir,
&gen_root,
&config,
&clock,
&mut manifest,
next_gsn,
)?;
generation.bind_fence(collection_fence.clone());
Arc::new(generation)
};
generations.reverse();
let core = Arc::new(Self {
meta,
dir: dir.to_path_buf(),
gen_root,
seg_root,
cache: SegBlockCache::new(config.block_cache_bytes),
shared,
config,
order,
prefix_filters: prefix_filters.to_vec(),
fs,
clock,
seed,
view: RwLock::new(Arc::new(View {
active,
frozen: generations,
sealed,
})),
manifest: Mutex::new(manifest),
collection_fence,
shut_down: AtomicBool::new(false),
seal: Mutex::new(SealState::default()),
seal_attempt: Mutex::new(()),
seal_cv: Condvar::new(),
signal: Arc::new(WorkerSignal::new()),
worker: Mutex::new(None),
last_tick_ms: AtomicU64::new(0),
_lease: lease,
});
if worker {
core.start_worker()?;
}
Ok(core)
}
fn create_first_generation(
fs: &Arc<dyn SegFs>,
dir: &Path,
gen_root: &Path,
config: &SegConfig,
clock: &Clock,
manifest: &mut Manifest,
next_gsn: u64,
) -> DbResult<Generation<K>> {
let (reserved, gen_id) = manifest.reserve_gen_id()?;
manifest::publish(&**fs, dir, &reserved).map_err(PublishError::into_inner)?;
*manifest = reserved;
super::failpoint!(GENERATION_ID_RESERVED);
let opened_at_ms = manifest.monotone_time(clock());
let generation = Generation::create(
fs.clone(),
gen_root,
gen_id,
config,
opened_at_ms,
manifest.order,
)?;
generation.seed_gsn(next_gsn);
super::failpoint!(GENERATION_CREATED);
let named = manifest
.with_active(GenRecord {
gen_id,
state: GenState::Active,
shard_count: generation.shard_count() as u8,
opened_at_ms,
frozen_at_ms: 0,
min_gsn: next_gsn,
max_gsn: 0,
})
.inspect_err(|_| generation.doom())?;
match manifest::publish(&**fs, dir, &named) {
Ok(()) => *manifest = named,
Err(PublishError::NotPublished(e)) => {
generation.doom();
return Err(e);
}
Err(PublishError::Indeterminate(e)) => {
return Err(e);
}
}
Ok(generation)
}
}
impl<K: Key + Hash + Eq + Send + Sync + 'static> SegCore<K> {
pub(crate) fn view(&self) -> Arc<View<K>> {
sync::read(&self.view).clone()
}
pub(crate) fn set_view(&self, view: View<K>) {
*sync::write(&self.view) = Arc::new(view);
}
pub(crate) fn now_ms(&self) -> u64 {
(self.clock)()
}
pub(crate) fn key_len(&self) -> u16 {
size_of::<K>() as u16
}
pub(crate) fn fence(&self, reason: String) -> DbError {
let mut fence = sync::lock(&self.collection_fence.reason);
if fence.is_none() {
tracing::error!(collection = self.meta.name, reason = %reason, "segmented collection fenced");
metrics::gauge!("armdb.seg.fenced", "collection" => self.meta.name).set(1.0);
*fence = Some(reason);
self.collection_fence.fenced.store(true, Ordering::Release);
}
DbError::CollectionFenced {
collection: self.meta.name,
reason: fence.clone().expect("set above"),
}
}
pub(crate) fn fence_reason(&self) -> Option<String> {
sync::lock(&self.collection_fence.reason).clone()
}
pub(crate) fn check_writable(&self) -> DbResult<()> {
self.collection_fence.check()
}
pub(crate) fn publish_next(&self, current: &mut Manifest, next: Manifest) -> DbResult<()> {
match manifest::publish(&*self.fs, &self.dir, &next) {
Ok(()) => {
*current = next;
Ok(())
}
Err(PublishError::NotPublished(e)) => Err(e),
Err(PublishError::Indeterminate(e)) => Err(self.fence(format!(
"the outcome of a manifest publication is unknown: {e}"
))),
}
}
pub(crate) fn get_pruned(&self, key: &K, since_ms: Option<u64>) -> DbResult<Option<Vec<u8>>> {
let h = key_hash(key.as_bytes(), self.seed);
let view = self.view();
let too_old = |frozen_at_ms: u64| since_ms.is_some_and(|since| frozen_at_ms < since);
match view.active.lookup(h, key)? {
GenLookup::Live(value) => return Ok(Some(value)),
GenLookup::Tombstone => return Ok(None),
GenLookup::Absent => {}
}
for generation in &view.frozen {
if too_old(generation.frozen_at_ms()) {
return Ok(None);
}
match generation.lookup(h, key)? {
GenLookup::Live(value) => return Ok(Some(value)),
GenLookup::Tombstone => return Ok(None),
GenLookup::Absent => {}
}
}
for segment in &view.sealed {
if too_old(segment.record().frozen_at_ms) {
return Ok(None);
}
match segment.lookup(h, key.as_bytes(), &self.cache)? {
Lookup::Live(value) => return Ok(Some(value)),
Lookup::Tombstone => return Ok(None),
Lookup::Absent => {}
}
}
Ok(None)
}
pub(crate) fn get(&self, key: &K) -> DbResult<Option<Vec<u8>>> {
self.get_pruned(key, None)
}
pub(crate) fn get_hinted(&self, key: &K, written_since_ms: u64) -> DbResult<Option<Vec<u8>>> {
self.get_pruned(key, Some(written_since_ms))
}
pub(crate) fn exists_in(
&self,
view: &View<K>,
h: u64,
key: &K,
with_active: bool,
since_ms: Option<u64>,
) -> DbResult<bool> {
if with_active {
match view.active.probe(h, key) {
GenProbe::Live => return Ok(true),
GenProbe::Tombstone => return Ok(false),
GenProbe::Absent => {}
}
}
for generation in &view.frozen {
if since_ms.is_some_and(|since| generation.frozen_at_ms() < since) {
return Ok(false);
}
match generation.probe(h, key) {
GenProbe::Live => return Ok(true),
GenProbe::Tombstone => return Ok(false),
GenProbe::Absent => {}
}
}
for segment in &view.sealed {
if since_ms.is_some_and(|since| segment.record().frozen_at_ms < since) {
return Ok(false);
}
match segment.lookup(h, key.as_bytes(), &self.cache)? {
Lookup::Live(_) => return Ok(true),
Lookup::Tombstone => return Ok(false),
Lookup::Absent => {}
}
}
Ok(false)
}
pub(crate) fn read_below(
&self,
view: &View<K>,
h: u64,
key: &K,
since_ms: Option<u64>,
) -> DbResult<Option<Vec<u8>>> {
for generation in &view.frozen {
if since_ms.is_some_and(|since| generation.frozen_at_ms() < since) {
return Ok(None);
}
match generation.lookup(h, key)? {
GenLookup::Live(value) => return Ok(Some(value)),
GenLookup::Tombstone => return Ok(None),
GenLookup::Absent => {}
}
}
for segment in &view.sealed {
if since_ms.is_some_and(|since| segment.record().frozen_at_ms < since) {
return Ok(None);
}
match segment.lookup(h, key.as_bytes(), &self.cache)? {
Lookup::Live(value) => return Ok(Some(value)),
Lookup::Tombstone => return Ok(None),
Lookup::Absent => {}
}
}
Ok(None)
}
pub(crate) fn contains_below(
&self,
view: &View<K>,
h: u64,
key: &K,
since_ms: Option<u64>,
) -> DbResult<bool> {
self.exists_in(view, h, key, false, since_ms)
}
pub(crate) fn contains(&self, key: &K) -> DbResult<bool> {
let h = key_hash(key.as_bytes(), self.seed);
self.exists_in(&self.view(), h, key, true, None)
}
pub(crate) fn len(&self) -> usize {
let view = self.view();
let generations: u64 = std::iter::once(&view.active)
.chain(view.frozen.iter())
.map(|g| g.live())
.sum();
let segments: u64 = view
.sealed
.iter()
.map(|s| s.record().entries - s.record().tombstones)
.sum();
(generations + segments) as usize
}
pub(crate) fn physical_entries(&self) -> u64 {
let view = self.view();
let generations: u64 = std::iter::once(&view.active)
.chain(view.frozen.iter())
.map(|g| g.keys())
.sum();
let segments: u64 = view.sealed.iter().map(|s| s.record().entries).sum();
generations + segments
}
}
impl<K: Key + Hash + Eq + Send + Sync + 'static> SegCore<K> {
fn for_each_generation(
&self,
mut f: impl FnMut(&Generation<K>) -> DbResult<()>,
) -> DbResult<()> {
let view = self.view();
let mut first = None;
for generation in view
.frozen
.iter()
.rev()
.chain(std::iter::once(&view.active))
{
if let Err(e) = f(generation)
&& first.is_none()
{
first = Some(e);
}
}
first.map_or(Ok(()), Err)
}
pub(crate) fn flush(&self) -> DbResult<()> {
self.for_each_generation(|g| g.flush_buffers())
}
pub(crate) fn durable_flush(&self) -> DbResult<()> {
self.for_each_generation(|g| g.durable_flush())
}
pub(crate) fn dirty_shards(&self) -> usize {
let view = self.view();
view.frozen
.iter()
.chain(std::iter::once(&view.active))
.map(|g| g.dirty_shards())
.sum()
}
pub(crate) fn clean_shutdown(&self) -> DbResult<()> {
self.stop_worker();
self.seal_cv.notify_all();
self.for_each_generation(|g| {
let hints = g.write_hints();
let close = g.close();
hints.and(close)
})
}
}
impl<K: Key + Hash + Eq + Send + Sync> Drop for SegCore<K> {
fn drop(&mut self) {
{
let _manifest = sync::lock(&self.manifest);
self.shut_down.store(true, Ordering::Release);
}
self.signal.stop();
let handle = sync::lock(&self.worker).take();
if let Some(handle) = handle
&& handle.thread().id() != std::thread::current().id()
{
let _ = handle.join();
}
}
}
#[cfg(test)]
mod tests {
#[test]
fn preparation_joins_a_later_panic_after_an_ordinary_error() {
let result = std::thread::scope(|scope| {
let first = scope.spawn(|| Err::<(), _>(DbError::Internal("first error")));
let later = scope.spawn(|| -> DbResult<()> { panic!("later preparation panic") });
join_preparations(vec![first, later])
});
assert!(matches!(result, Err(DbError::Internal("first error"))));
let result = std::thread::scope(|scope| {
join_preparations(vec![
scope.spawn(|| -> DbResult<()> { panic!("preparation panic") }),
])
});
assert!(matches!(result, Err(DbError::RecoveryPanic)));
}
use std::time::Duration;
use super::*;
use crate::error::DbError;
use crate::seg::fs::{FsOpKind, TraceFs};
use crate::seg::manifest::{MANIFEST_NAME, MANIFEST_TMP, load};
use crate::seg::seal::{sdat_name, sidx_name};
use crate::seg::testkit::{
self, KEY_LEN, SEED, TestClock, build_collection, copy_collection, key_of, open_core,
try_open_core,
};
#[test]
fn batched_reopen_matches_newest_first_prefix_across_boundaries() {
let dir = tempfile::tempdir().unwrap();
let mut manifest = Manifest::new(KEY_LEN as u16, SEED, 0);
for id in 1..=21 {
let entries = testkit::entries(id * 20, 1);
let mut rec =
testkit::write_segment(super::super::fs::real(), dir.path(), id, &entries);
rec.frozen_at_ms = id;
manifest.segments.push(rec);
}
let shared = Arc::new(SegShared::new());
let costs: Vec<_> = load_segments(
&super::super::fs::real(),
dir.path(),
&manifest,
&shared,
None,
)
.unwrap()
.iter()
.map(|s| s.cost())
.collect();
for prefix in [0, 1, 7, 8, 9, 16, 17, 21] {
let exact: u64 = costs[..prefix].iter().sum();
let slack = costs.get(prefix).map_or(exact, |next| exact + next - 1);
for budget in [exact, slack] {
let loaded = load_segments(
&super::super::fs::real(),
dir.path(),
&manifest,
&shared,
Some(budget),
)
.unwrap();
assert_eq!(loaded.iter().take_while(|s| s.is_hot()).count(), prefix);
assert!(loaded.iter().skip(prefix).all(|s| !s.is_hot()));
assert_eq!(loaded.iter().map(|s| s.cost()).collect::<Vec<_>>(), costs);
}
}
}
#[cfg(target_os = "linux")]
#[test]
fn default_reopen_bounds_checked_descriptors() {
const CHILD: &str = "ARMDB_TASK5_FD_CHILD";
if std::env::var_os(CHILD).is_none() {
let output = std::process::Command::new(std::env::current_exe().unwrap())
.args([
"--exact",
"seg::core::tests::default_reopen_bounds_checked_descriptors",
"--nocapture",
])
.env(CHILD, "1")
.output()
.unwrap();
assert!(
output.status.success(),
"child: {}",
String::from_utf8_lossy(&output.stderr)
);
return;
}
let dir = tempfile::tempdir().unwrap();
let mut manifest = Manifest::new(KEY_LEN as u16, SEED, 0);
let entries = testkit::entries(3, 1);
for id in 1..=180 {
let mut rec =
testkit::write_segment(super::super::fs::real(), dir.path(), id, &entries);
rec.frozen_at_ms = id;
manifest.segments.push(rec);
}
let limit = libc::rlimit {
rlim_cur: 256,
rlim_max: 256,
};
assert_eq!(unsafe { libc::setrlimit(libc::RLIMIT_NOFILE, &limit) }, 0);
let shared = Arc::new(SegShared::new());
let loaded = load_segments(
&super::super::fs::real(),
dir.path(),
&manifest,
&shared,
None,
)
.unwrap();
assert_eq!(loaded.len(), 180);
assert!(loaded.iter().all(|s| s.is_hot()));
assert_eq!(loaded.first().unwrap().record().segment_id, 180);
assert_eq!(loaded.last().unwrap().record().segment_id, 1);
}
#[test]
fn deferred_open_starts_no_worker_until_requested() {
let dir = tempfile::tempdir().unwrap();
let meta = SegMeta {
name: "deferred",
typ_hash: 1,
value_version: 1,
};
let core = SegCore::<testkit::TestKey>::open_deferred(
dir.path(),
meta,
SegConfig::test(),
OpenOptions::production(),
)
.unwrap();
assert!(!core.worker_running());
core.start_background().unwrap();
assert!(core.worker_running());
let worker_id = sync::lock(&core.worker).as_ref().unwrap().thread().id();
core.start_background().unwrap();
assert_eq!(
sync::lock(&core.worker).as_ref().unwrap().thread().id(),
worker_id,
"repeated startup must retain the original worker handle"
);
core.stop_worker();
assert!(!core.worker_running());
drop(core);
let core = SegCore::<testkit::TestKey>::open(
dir.path(),
meta,
SegConfig::test(),
OpenOptions::production(),
)
.unwrap();
assert!(core.worker_running());
}
#[test]
fn start_background_concurrently_retains_one_worker() {
let dir = tempfile::tempdir().unwrap();
let core = SegCore::<testkit::TestKey>::open_deferred(
dir.path(),
SegMeta {
name: "concurrent-start",
typ_hash: 1,
value_version: 1,
},
SegConfig::test(),
OpenOptions::production(),
)
.unwrap();
let barrier = std::sync::Barrier::new(8);
let ids = std::thread::scope(|scope| {
let callers: Vec<_> = (0..8)
.map(|_| {
scope.spawn(|| {
barrier.wait();
core.start_background().unwrap();
sync::lock(&core.worker).as_ref().unwrap().thread().id()
})
})
.collect();
callers
.into_iter()
.map(|caller| caller.join().unwrap())
.collect::<Vec<_>>()
});
let first = ids[0];
let retained = sync::lock(&core.worker).as_ref().unwrap().thread().id();
assert!(ids.iter().all(|id| *id == first));
assert_eq!(retained, first);
let barrier = std::sync::Barrier::new(8);
std::thread::scope(|scope| {
for _ in 0..8 {
let barrier = &barrier;
let core = &core;
scope.spawn(move || {
barrier.wait();
core.start_background().unwrap();
assert_eq!(
sync::lock(&core.worker).as_ref().unwrap().thread().id(),
first
);
});
}
});
core.stop_worker();
assert!(!core.worker_running());
}
#[test]
fn hinted_lower_reads_skip_layers_frozen_before_the_hint() {
let dir = tempfile::tempdir().unwrap();
build_collection(dir.path());
let core = open_core(
dir.path(),
SegConfig {
block_cache_bytes: 0,
resident_metadata_bytes: Some(0),
..wide()
},
);
let view = core.view();
let key = key_of(50);
let h = key_hash(&key, core.seed);
let at = view
.sealed
.iter()
.find(|s| matches!(s.lookup(h, &key, &core.cache).unwrap(), Lookup::Live(_)))
.map(|s| s.record().frozen_at_ms)
.unwrap();
assert_eq!(
core.read_below(&view, h, &key, None).unwrap(),
Some(testkit::value_of(50))
);
assert_eq!(core.read_below(&view, h, &key, Some(at + 1)).unwrap(), None);
assert!(!core.contains_below(&view, h, &key, Some(at + 1)).unwrap());
assert!(core.contains_below(&view, h, &key, Some(at)).unwrap());
let frozen_key = key_of(150);
let fh = key_hash(&frozen_key, core.seed);
let frozen_at = view.frozen[0].frozen_at_ms();
assert!(
core.read_below(&view, fh, &frozen_key, Some(frozen_at))
.unwrap()
.is_some()
);
assert_eq!(
core.read_below(&view, fh, &frozen_key, Some(frozen_at + 1))
.unwrap(),
None
);
assert!(
!core
.contains_below(&view, fh, &frozen_key, Some(frozen_at + 1))
.unwrap()
);
core.put(&key, b"active").unwrap();
assert!(
core.exists_in(&core.view(), h, &key, true, Some(u64::MAX))
.unwrap()
);
}
#[test]
fn held_lower_reads_skip_active_and_obey_tombstones_and_errors() {
let dir = tempfile::tempdir().unwrap();
build_collection(dir.path());
let core = open_core(
dir.path(),
SegConfig {
block_cache_bytes: 0,
..wide()
},
);
let key = key_of(50);
core.put(&key, b"newer").unwrap();
let view = core.view();
let held = view
.active
.lock_owned(&(0..view.active.shard_count()).collect::<Vec<_>>())
.unwrap();
let h = key_hash(&key, core.seed);
assert_eq!(
core.read_below(&view, h, &key, None).unwrap(),
Some(testkit::value_of(50))
);
assert!(core.contains_below(&view, h, &key, None).unwrap());
let deleted = key_of(105);
let dh = key_hash(&deleted, core.seed);
assert_eq!(core.read_below(&view, dh, &deleted, None).unwrap(), None);
assert!(!core.contains_below(&view, dh, &deleted, None).unwrap());
std::fs::OpenOptions::new()
.write(true)
.open(dir.path().join("seg").join(sdat_name(1, 1)))
.unwrap()
.set_len(64)
.unwrap();
assert!(core.read_below(&view, h, &key, None).is_err());
assert!(core.contains_below(&view, h, &key, None).is_err());
drop(held);
}
#[test]
fn a_shutdown_hint_error_still_flushes_the_remaining_shards() {
let dir = tempfile::tempdir().unwrap();
let core = open_core(dir.path(), wide());
for i in 0..100 {
core.put(&key_of(i), b"v").unwrap();
}
assert_eq!(core.dirty_shards(), 2);
let shard = dir.path().join("gen/0000000000000001/shard_000");
let journal = std::fs::read_dir(&shard)
.unwrap()
.map(|entry| entry.unwrap().path())
.find(|path| {
path.extension()
.is_some_and(|extension| extension == "data")
})
.unwrap();
let moved = journal.with_extension("moved");
std::fs::rename(&journal, &moved).unwrap();
let result = core.clean_shutdown();
std::fs::rename(&moved, &journal).unwrap();
assert!(
matches!(result, Err(DbError::Io(ref error)) if error.kind() == std::io::ErrorKind::NotFound)
);
assert_eq!(
core.dirty_shards(),
0,
"close must flush after a hint error"
);
}
#[test]
fn a_generation_barrier_attempts_all_generations_and_returns_the_first_error() {
let dir = tempfile::tempdir().unwrap();
let core = open_core(dir.path(), wide());
core.put(&key_of(0), b"first").unwrap();
core.seal().unwrap();
core.put(&key_of(1), b"second").unwrap();
core.seal().unwrap();
core.put(&key_of(2), b"active").unwrap();
let mut attempted = Vec::new();
let error = core
.for_each_generation(|generation| {
attempted.push(generation.id());
Err(DbError::Client(if attempted.len() == 1 {
"first barrier error"
} else {
"later barrier error"
}))
})
.unwrap_err();
assert_eq!(attempted, [1, 2, 3]);
assert!(matches!(error, DbError::Client("first barrier error")));
}
fn wide() -> SegConfig {
SegConfig {
seal_max_keys: 1_000_000,
max_frozen_generations: 8,
..SegConfig::test()
}
}
#[test]
fn a_barrier_covers_frozen_generations() {
let dir = tempfile::tempdir().unwrap();
let core = open_core(dir.path(), wide());
for i in 0..200 {
core.put(&key_of(i), b"in the frozen generation").unwrap();
}
core.seal().unwrap();
for i in 200..300 {
core.put(&key_of(i), b"in the active generation").unwrap();
}
assert!(core.dirty_shards() > 0);
assert!(
core.view().frozen[0].dirty_shards() > 0,
"the freeze did not flush"
);
core.durable_flush().unwrap();
assert_eq!(core.dirty_shards(), 0);
let crashed = tempfile::tempdir().unwrap();
copy_collection(dir.path(), crashed.path());
let recovered = open_core(crashed.path(), wide());
for i in 0..300 {
assert!(recovered.get(&key_of(i)).unwrap().is_some(), "key {i}");
}
assert_eq!(recovered.view().frozen.len(), 1);
}
#[test]
fn a_plain_flush_empties_the_buffers_of_every_generation() {
let dir = tempfile::tempdir().unwrap();
let core = open_core(dir.path(), wide());
for i in 0..50 {
core.put(&key_of(i), b"v").unwrap();
}
core.seal().unwrap();
for i in 50..100 {
core.put(&key_of(i), b"v").unwrap();
}
core.flush().unwrap();
let crashed = tempfile::tempdir().unwrap();
copy_collection(dir.path(), crashed.path());
let recovered = open_core(crashed.path(), wide());
for i in 0..100 {
assert!(recovered.get(&key_of(i)).unwrap().is_some(), "key {i}");
}
}
#[test]
fn a_clean_shutdown_leaves_every_generation_durable_and_hinted() {
let dir = tempfile::tempdir().unwrap();
let core = open_core(dir.path(), wide());
for i in 0..50 {
core.put(&key_of(i), b"v").unwrap();
}
core.seal().unwrap();
for i in 50..100 {
core.put(&key_of(i), b"v").unwrap();
}
core.clean_shutdown().unwrap();
assert_eq!(core.dirty_shards(), 0);
for generation in ["gen/0000000000000001", "gen/0000000000000002"] {
let hints = std::fs::read_dir(dir.path().join(generation).join("shard_000"))
.unwrap()
.filter(|e| {
e.as_ref()
.unwrap()
.path()
.extension()
.is_some_and(|x| x == "hint")
})
.count();
assert!(hints > 0, "{generation} has no hint file");
}
core.clean_shutdown().unwrap();
}
#[test]
fn after_a_shutdown_nothing_is_frozen_or_sealed() {
let dir = tempfile::tempdir().unwrap();
let config = SegConfig {
seal_max_keys: 5,
max_frozen_generations: 4,
seal_wait_timeout: Duration::from_secs(5),
..SegConfig::test()
};
let core = open_core(dir.path(), config);
for i in 0..3 {
core.put(&key_of(i), b"v").unwrap();
}
core.seal().unwrap();
core.clean_shutdown().unwrap();
core.put(&key_of(10), b"v").unwrap();
core.put(&key_of(11), b"v").unwrap();
for i in 12..15 {
core.put(&key_of(i), b"v").unwrap();
}
assert!(core.view().active.is_full());
let started = std::time::Instant::now();
assert!(matches!(
core.put(&key_of(99), b"v"),
Err(DbError::SealBackpressure { .. })
));
assert!(
started.elapsed() < Duration::from_secs(1),
"a shut-down collection does not wait for a seal that cannot come"
);
assert_eq!(core.view().frozen.len(), 1, "no freeze after the shutdown");
assert!(core.seal_oldest().is_err());
assert_eq!(
std::fs::read_dir(dir.path().join("seg")).unwrap().count(),
0
);
core.tick().unwrap();
assert_eq!(core.view().frozen.len(), 1);
}
fn layered(dir: &Path, clock: &TestClock) -> Arc<SegCore<crate::seg::testkit::TestKey>> {
let config = SegConfig {
seal_max_keys: 1_000_000,
max_frozen_generations: 8,
..SegConfig::test()
};
let core = try_open_core(dir, config, crate::seg::fs::real(), clock).unwrap();
clock.set(1_000);
core.put(&key_of(b'A' as u64), b"a").unwrap();
core.put(&key_of(0xA2), b"a2").unwrap();
core.seal().unwrap();
core.seal_oldest().unwrap();
clock.set(2_000);
core.put(&key_of(b'B' as u64), b"b").unwrap();
core.delete(&key_of(0xA2)).unwrap();
core.seal().unwrap();
core.seal_oldest().unwrap();
clock.set(2_100);
core.put(&key_of(b'E' as u64), b"e").unwrap();
clock.set(3_000);
core.put(&key_of(b'C' as u64), b"c").unwrap();
core.seal().unwrap();
clock.set(4_000);
core.put(&key_of(b'D' as u64), b"d").unwrap();
core
}
fn hinted(
core: &SegCore<crate::seg::testkit::TestKey>,
name: u8,
since: u64,
) -> Option<Vec<u8>> {
core.get_hinted(&key_of(name as u64), since).unwrap()
}
#[test]
fn a_hint_prunes_layers_frozen_before_it() {
let dir = tempfile::tempdir().unwrap();
let clock = TestClock::new(1);
let core = layered(dir.path(), &clock);
for name in *b"ABCDE" {
assert!(hinted(&core, name, 0).is_some(), "{}", name as char);
}
assert_eq!(hinted(&core, b'A', 1_000), Some(b"a".to_vec()));
assert_eq!(
hinted(&core, b'A', 1_001),
None,
"its layer froze before the hint"
);
assert_eq!(hinted(&core, b'B', 2_000), Some(b"b".to_vec()));
assert_eq!(hinted(&core, b'B', 2_001), None);
assert_eq!(hinted(&core, b'C', 3_000), Some(b"c".to_vec()));
assert_eq!(hinted(&core, b'C', 3_001), None);
}
#[test]
fn the_active_generation_is_always_consulted() {
let dir = tempfile::tempdir().unwrap();
let clock = TestClock::new(1);
let core = layered(dir.path(), &clock);
assert_eq!(hinted(&core, b'D', u64::MAX), Some(b"d".to_vec()));
assert_eq!(hinted(&core, b'C', u64::MAX), None);
}
#[test]
fn a_version_older_than_the_hint_is_returned_when_its_layer_is_newer() {
let dir = tempfile::tempdir().unwrap();
let clock = TestClock::new(1);
let core = layered(dir.path(), &clock);
assert_eq!(hinted(&core, b'E', 2_500), Some(b"e".to_vec()));
}
#[test]
fn a_newer_tombstone_is_never_skipped() {
let dir = tempfile::tempdir().unwrap();
let clock = TestClock::new(1);
let core = layered(dir.path(), &clock);
for since in [0, 1_000, 1_500, 2_000] {
assert_eq!(
core.get_hinted(&key_of(0xA2), since).unwrap(),
None,
"hint {since}"
);
}
assert_eq!(core.get(&key_of(0xA2)).unwrap(), None);
}
#[test]
fn a_clock_that_went_back_does_not_reorder_the_layers() {
let dir = tempfile::tempdir().unwrap();
let clock = TestClock::new(1);
let config = SegConfig {
seal_max_keys: 1_000_000,
max_frozen_generations: 8,
..SegConfig::test()
};
let core = try_open_core(dir.path(), config, crate::seg::fs::real(), &clock).unwrap();
clock.set(5_000);
core.put(&key_of(1), b"old").unwrap();
core.seal().unwrap();
clock.set(100);
core.delete(&key_of(1)).unwrap();
core.seal().unwrap();
let view = core.view();
assert_eq!(view.frozen[0].frozen_at_ms(), 5_000, "clamped by I7");
assert_eq!(view.frozen[1].frozen_at_ms(), 5_000);
assert_eq!(core.get_hinted(&key_of(1), 5_000).unwrap(), None);
}
fn config() -> SegConfig {
SegConfig::test()
}
fn tree(dir: &Path) -> Vec<String> {
fn walk(base: &Path, dir: &Path, out: &mut Vec<String>) {
for entry in std::fs::read_dir(dir).unwrap() {
let path = entry.unwrap().path();
out.push(path.strip_prefix(base).unwrap().display().to_string());
if path.is_dir() {
walk(base, &path, out);
}
}
}
let mut out = Vec::new();
walk(dir, dir, &mut out);
out.retain(|p| !p.ends_with("db.lock"));
out.sort();
out
}
#[test]
fn a_new_collection_has_one_active_generation() {
let dir = tempfile::tempdir().unwrap();
let core = open_core(dir.path(), config());
assert_eq!(core.len(), 0);
assert_eq!(core.get(&key_of(1)).unwrap(), None);
assert_eq!(core.key_len(), KEY_LEN as u16);
let view = core.view();
assert_eq!(view.active.id(), 1);
assert!(view.frozen.is_empty() && view.sealed.is_empty());
assert_eq!(view.active.next_gsn(), 1);
let manifest = load(dir.path()).unwrap().unwrap();
assert_eq!(manifest.generations.len(), 1);
assert_eq!(manifest.next_gen_id, 2);
assert_eq!(manifest.key_len, KEY_LEN as u16);
assert_eq!(manifest.seed, core.seed);
assert!(dir.path().join("db.meta").is_file());
assert!(dir.path().join("gen/0000000000000001").is_dir());
assert!(dir.path().join("seg").is_dir());
}
#[test]
fn two_collections_get_different_seeds() {
let a = tempfile::tempdir().unwrap();
let b = tempfile::tempdir().unwrap();
assert_ne!(
open_core(a.path(), config()).seed,
open_core(b.path(), config()).seed
);
}
#[test]
fn creation_publishes_a_manifest_before_the_first_generation_exists() {
let dir = tempfile::tempdir().unwrap();
let fs = TraceFs::new();
let _core = try_open_core(dir.path(), config(), fs.clone(), &TestClock::new(5)).unwrap();
let first_manifest = fs.position(FsOpKind::Rename, MANIFEST_NAME).unwrap();
let generation = fs.position(FsOpKind::SyncDir, "0000000000000001").unwrap();
assert!(first_manifest < generation);
let publications = fs
.ops()
.iter()
.filter(|op| op.kind() == FsOpKind::Rename && op.target().ends_with(MANIFEST_NAME))
.count();
assert_eq!(publications, 3);
}
#[test]
fn an_interrupted_creation_is_completed_by_the_next_open() {
let dir = tempfile::tempdir().unwrap();
create_layout(&*crate::seg::fs::real(), dir.path()).unwrap();
let manifest = Manifest::new(KEY_LEN as u16, SEED, 1);
manifest::publish(&*crate::seg::fs::real(), dir.path(), &manifest).unwrap();
let core = open_core(dir.path(), config());
assert_eq!(core.view().active.id(), 1);
assert_eq!(core.seed, SEED);
}
#[test]
fn an_unknown_naming_of_the_first_generation_keeps_its_directory() {
fn prepare(dir: &Path) {
create_layout(&*crate::seg::fs::real(), dir).unwrap();
let manifest = Manifest::new(KEY_LEN as u16, SEED, 1);
manifest::publish(&*crate::seg::fs::real(), dir, &manifest).unwrap();
}
let dry = tempfile::tempdir().unwrap();
prepare(dry.path());
let trace = TraceFs::new();
drop(try_open_core(dry.path(), config(), trace.clone(), &TestClock::new(1)).unwrap());
let syncs: Vec<_> = trace
.ops()
.into_iter()
.filter(|op| op.kind() == FsOpKind::SyncDir)
.collect();
let naming = syncs
.iter()
.rposition(|op| op.target() == dry.path())
.unwrap();
let dir = tempfile::tempdir().unwrap();
prepare(dir.path());
let fs = TraceFs::new();
fs.fail_on(FsOpKind::SyncDir, "", naming);
assert!(try_open_core(dir.path(), config(), fs, &TestClock::new(1)).is_err());
assert!(
dir.path().join("gen/0000000000000001").is_dir(),
"an Indeterminate publication must not doom the generation"
);
let visible = load(dir.path()).unwrap().unwrap();
assert_eq!(visible.active().map(|g| g.gen_id), Some(1));
let core = open_core(dir.path(), config());
assert_eq!(core.view().active.id(), 1);
}
#[test]
fn data_without_a_manifest_is_refused_and_left_alone() {
let dir = tempfile::tempdir().unwrap();
std::fs::create_dir_all(dir.path().join("gen/0000000000000007/shard_000")).unwrap();
let before = tree(dir.path());
let err = try_open_core(
dir.path(),
config(),
crate::seg::fs::real(),
&TestClock::new(1),
)
.err()
.unwrap();
assert!(
matches!(err, DbError::ManifestCorrupt { reason, .. } if reason.contains("missing"))
);
assert_eq!(tree(dir.path()), before);
}
#[test]
fn a_directory_of_another_backend_is_refused() {
let dir = tempfile::tempdir().unwrap();
let meta = DbMeta {
version: META_VERSION,
backend: Backend::Bitcask,
shard_count: 2,
shard_prefix_bits: 0,
flags: 0,
};
std::fs::write(dir.path().join("db.meta"), meta.encode()).unwrap();
let err = try_open_core(
dir.path(),
config(),
crate::seg::fs::real(),
&TestClock::new(1),
)
.err()
.unwrap();
assert!(matches!(err, DbError::FormatMismatch(m) if m.contains("backend")));
}
#[test]
fn another_key_length_is_refused() {
let dir = tempfile::tempdir().unwrap();
drop(open_core(dir.path(), config()));
let result: DbResult<Arc<SegCore<[u8; 16]>>> = SegCore::open(
dir.path(),
testkit::meta(),
config(),
OpenOptions {
fs: crate::seg::fs::real(),
clock: wall_clock(),
worker: false,
},
);
assert!(
matches!(result.err().unwrap(), DbError::FormatMismatch(m) if m.contains("key length"))
);
}
#[test]
fn a_collection_cannot_be_opened_twice() {
let dir = tempfile::tempdir().unwrap();
let _first = open_core(dir.path(), config());
let second = try_open_core(
dir.path(),
config(),
crate::seg::fs::real(),
&TestClock::new(1),
);
assert!(matches!(second.err().unwrap(), DbError::Locked { .. }));
}
fn expected(i: u64) -> Option<Vec<u8>> {
match i {
200..210 => None,
210..300 => Some(format!("active-{i}").into_bytes()),
100..110 => None,
110..200 => Some(format!("frozen-{i}").into_bytes()),
0..100 if i % 10 == 9 => None,
0..100 => Some(testkit::value_of(i)),
_ => None,
}
}
#[test]
fn reads_take_the_newest_layer() {
let dir = tempfile::tempdir().unwrap();
build_collection(dir.path());
let core = open_core(dir.path(), config());
let view = core.view();
assert_eq!(view.active.id(), 2);
assert_eq!(view.frozen.len(), 1);
assert!(view.frozen[0].is_frozen());
assert_eq!(view.sealed.len(), 1);
for i in 0..320u64 {
let key = key_of(i);
assert_eq!(core.get(&key).unwrap(), expected(i), "key {i}");
assert_eq!(
core.contains(&key).unwrap(),
expected(i).is_some(),
"key {i}"
);
}
}
#[test]
fn len_counts_live_entries_of_every_layer() {
let dir = tempfile::tempdir().unwrap();
build_collection(dir.path());
let core = open_core(dir.path(), config());
assert_eq!(core.len(), 180 + 140 + 90);
}
#[test]
fn the_gsn_continues_above_everything_recovered() {
let dir = tempfile::tempdir().unwrap();
build_collection(dir.path());
let core = open_core(dir.path(), config());
assert_eq!(core.view().active.next_gsn(), 451);
assert_eq!(core.view().active.min_gsn(), 351);
}
#[test]
fn the_floor_wins_over_a_journal_that_lost_its_tail() {
let dir = tempfile::tempdir().unwrap();
drop(open_core(dir.path(), config()));
let mut manifest = load(dir.path()).unwrap().unwrap();
manifest.gsn_floor = 500;
manifest.generations[0].min_gsn = 501;
manifest.manifest_version += 1;
manifest::publish(&*crate::seg::fs::real(), dir.path(), &manifest).unwrap();
let core = open_core(dir.path(), config());
assert_eq!(core.view().active.next_gsn(), 501);
}
#[test]
fn garbage_is_removed_by_a_successful_open() {
let dir = tempfile::tempdir().unwrap();
build_collection(dir.path());
std::fs::create_dir_all(dir.path().join("gen/00000000000000ff/shard_000")).unwrap();
std::fs::write(dir.path().join("seg/00000000000000ee-0001.sdat"), b"stray").unwrap();
std::fs::write(
dir.path().join("seg/0000000000000002-0001.sdat.tmp"),
b"torn",
)
.unwrap();
std::fs::write(dir.path().join(MANIFEST_TMP), b"torn").unwrap();
let _core = open_core(dir.path(), config());
assert!(!dir.path().join("gen/00000000000000ff").exists());
assert!(!dir.path().join("seg/00000000000000ee-0001.sdat").exists());
assert!(
!dir.path()
.join("seg/0000000000000002-0001.sdat.tmp")
.exists()
);
assert!(!dir.path().join(MANIFEST_TMP).exists());
assert!(dir.path().join("seg").join(sdat_name(1, 1)).exists());
assert!(dir.path().join("seg").join(sidx_name(1, 1)).exists());
assert!(dir.path().join("gen/0000000000000001").exists());
}
#[test]
fn the_manifest_is_made_durable_before_garbage_is_removed() {
let dir = tempfile::tempdir().unwrap();
build_collection(dir.path());
std::fs::create_dir_all(dir.path().join("gen/00000000000000ff")).unwrap();
let fs = TraceFs::new();
drop(try_open_core(dir.path(), config(), fs.clone(), &TestClock::new(1)).unwrap());
let ops = fs.ops();
let synced = ops
.iter()
.position(|op| op.kind() == FsOpKind::SyncDir && op.target() == dir.path())
.expect("open syncs the collection directory");
let first_removal = ops
.iter()
.position(|op| matches!(op.kind(), FsOpKind::RemoveFile | FsOpKind::RemoveDirAll))
.expect("open removes garbage");
assert!(synced < first_removal, "{ops:?}");
assert!(!dir.path().join("gen/00000000000000ff").exists());
}
#[test]
fn an_open_that_cannot_make_the_manifest_durable_removes_nothing() {
let dir = tempfile::tempdir().unwrap();
build_collection(dir.path());
std::fs::create_dir_all(dir.path().join("gen/00000000000000ff")).unwrap();
let before = tree(dir.path());
let fs = TraceFs::new();
fs.fail_on(FsOpKind::SyncDir, "", 0);
assert!(try_open_core(dir.path(), config(), fs, &TestClock::new(1)).is_err());
assert_eq!(tree(dir.path()), before);
}
#[test]
fn a_failed_open_changes_nothing() {
let dir = tempfile::tempdir().unwrap();
build_collection(dir.path());
std::fs::create_dir_all(dir.path().join("gen/00000000000000ff")).unwrap();
std::fs::write(dir.path().join(MANIFEST_TMP), b"torn").unwrap();
std::fs::remove_file(dir.path().join("seg").join(sidx_name(1, 1))).unwrap();
let before = tree(dir.path());
let err = try_open_core(
dir.path(),
config(),
crate::seg::fs::real(),
&TestClock::new(1),
)
.err()
.unwrap();
assert!(matches!(err, DbError::SegmentMissing { segment_id: 1, .. }));
assert_eq!(tree(dir.path()), before);
}
fn storage_bytes(dir: &Path) -> Vec<(String, Vec<u8>)> {
tree(dir)
.into_iter()
.filter_map(|name| {
let path = dir.join(&name);
path.is_file().then(|| (name, std::fs::read(path).unwrap()))
})
.collect()
}
#[test]
fn a_same_length_corrupt_sidecar_preserves_storage_and_garbage() {
let dir = tempfile::tempdir().unwrap();
build_collection(dir.path());
std::fs::create_dir_all(dir.path().join("gen/00000000000000ff")).unwrap();
std::fs::write(dir.path().join("seg/garbage.tmp"), b"must stay").unwrap();
std::fs::write(dir.path().join(MANIFEST_TMP), b"must also stay").unwrap();
let sidecar = dir.path().join("seg").join(sidx_name(1, 1));
let mut bytes = std::fs::read(&sidecar).unwrap();
bytes[64] ^= 1;
std::fs::write(sidecar, bytes).unwrap();
let before_tree = tree(dir.path());
let before_bytes = storage_bytes(dir.path());
let config = SegConfig {
resident_metadata_bytes: None,
..config()
};
let err = try_open_core(
dir.path(),
config,
crate::seg::fs::real(),
&TestClock::new(1),
)
.err()
.unwrap();
assert!(matches!(err, DbError::SegmentCorrupt { segment_id: 1, .. }));
assert_eq!(tree(dir.path()), before_tree);
assert_eq!(storage_bytes(dir.path()), before_bytes);
}
#[test]
fn all_generation_structures_are_validated_before_recovery() {
let dir = tempfile::tempdir().unwrap();
build_collection(dir.path());
std::fs::create_dir_all(dir.path().join("gen/00000000000000ff")).unwrap();
std::fs::write(dir.path().join(MANIFEST_TMP), b"must stay").unwrap();
use std::io::Write;
let mut journal = std::fs::OpenOptions::new()
.append(true)
.open(
dir.path()
.join("gen/0000000000000001/shard_000/000001.data"),
)
.unwrap();
journal.write_all(b"torn tail").unwrap();
drop(journal);
std::fs::remove_dir_all(dir.path().join("gen/0000000000000002/shard_000")).unwrap();
let before_tree = tree(dir.path());
let before_bytes = storage_bytes(dir.path());
let err = try_open_core(
dir.path(),
config(),
crate::seg::fs::real(),
&TestClock::new(1),
)
.err()
.unwrap();
assert!(matches!(err, DbError::GenerationMissing { gen_id: 2, .. }));
assert_eq!(tree(dir.path()), before_tree);
assert_eq!(storage_bytes(dir.path()), before_bytes);
}
#[test]
fn encrypted_generation_metadata_is_rejected_before_recovery() {
let dir = tempfile::tempdir().unwrap();
build_collection(dir.path());
std::fs::create_dir_all(dir.path().join("gen/00000000000000ff")).unwrap();
std::fs::write(dir.path().join("seg/garbage.tmp"), b"must stay").unwrap();
std::fs::write(dir.path().join(MANIFEST_TMP), b"must also stay").unwrap();
use std::io::Write;
let mut journal = std::fs::OpenOptions::new()
.append(true)
.open(
dir.path()
.join("gen/0000000000000001/shard_000/000001.data"),
)
.unwrap();
journal.write_all(b"torn tail").unwrap();
drop(journal);
let meta_path = dir.path().join("gen/0000000000000002/db.meta");
let mut bytes = std::fs::read(&meta_path).unwrap();
bytes[8] = 1; std::fs::write(meta_path, bytes).unwrap();
let before_tree = tree(dir.path());
let before_bytes = storage_bytes(dir.path());
let err = try_open_core(
dir.path(),
config(),
crate::seg::fs::real(),
&TestClock::new(1),
)
.err()
.unwrap();
assert_eq!(tree(dir.path()), before_tree);
assert_eq!(storage_bytes(dir.path()), before_bytes);
assert!(matches!(err, DbError::GenerationMissing { gen_id: 2, .. }));
}
#[test]
fn a_missing_generation_fails_the_open_and_is_not_recreated() {
let dir = tempfile::tempdir().unwrap();
build_collection(dir.path());
std::fs::remove_dir_all(dir.path().join("gen/0000000000000001")).unwrap();
let before = tree(dir.path());
let err = try_open_core(
dir.path(),
config(),
crate::seg::fs::real(),
&TestClock::new(1),
)
.err()
.unwrap();
assert!(matches!(err, DbError::GenerationMissing { gen_id: 1, .. }));
assert_eq!(tree(dir.path()), before);
}
#[test]
fn the_shard_count_may_change_between_opens() {
let dir = tempfile::tempdir().unwrap();
build_collection(dir.path());
let wider = SegConfig {
shard_count: 8,
..config()
};
let core = open_core(dir.path(), wider);
assert_eq!(
core.view().active.shard_count(),
2,
"an existing generation keeps its count"
);
for i in [0u64, 105, 150, 205, 250] {
assert_eq!(core.get(&key_of(i)).unwrap(), expected(i), "key {i}");
}
}
#[test]
fn a_fenced_collection_still_reads() {
let dir = tempfile::tempdir().unwrap();
build_collection(dir.path());
let core = open_core(dir.path(), config());
core.check_writable().unwrap();
let err = core.fence("test".into());
assert!(matches!(
err,
DbError::CollectionFenced {
collection: "test_seg",
..
}
));
assert!(matches!(
core.check_writable(),
Err(DbError::CollectionFenced { reason, .. }) if reason == "test"
));
assert_eq!(core.fence_reason().as_deref(), Some("test"));
assert_eq!(core.get(&key_of(150)).unwrap(), expected(150));
core.fence("later".into());
assert_eq!(core.fence_reason().as_deref(), Some("test"));
}
#[test]
fn a_failed_publication_is_reported_and_an_unknown_one_fences() {
let dir = tempfile::tempdir().unwrap();
let fs = TraceFs::new();
let core = try_open_core(dir.path(), config(), fs.clone(), &TestClock::new(1)).unwrap();
fs.fail_on(FsOpKind::Rename, MANIFEST_NAME, 0);
{
let mut manifest = sync::lock(&core.manifest);
let version = manifest.manifest_version;
let (next, _) = manifest.reserve_segment_id().unwrap();
assert!(core.publish_next(&mut manifest, next).is_err());
assert_eq!(manifest.manifest_version, version, "nothing was published");
}
core.check_writable().unwrap();
fs.fail_on(FsOpKind::SyncDir, "", 0);
{
let mut manifest = sync::lock(&core.manifest);
let (next, _) = manifest.reserve_segment_id().unwrap();
let err = core.publish_next(&mut manifest, next).unwrap_err();
assert!(matches!(err, DbError::CollectionFenced { .. }));
}
assert!(core.check_writable().is_err());
}
#[derive(Clone, Copy)]
struct TypedTreeKey([u8; 24]);
impl Key for TypedTreeKey {
const KEY_SCHEME: armour_core::KeyScheme = armour_core::KeyScheme::Typed(&[
armour_core::KeyType::Fuid,
armour_core::KeyType::Fuid,
armour_core::KeyType::U64,
]);
fn as_bytes(&self) -> &[u8] {
&self.0
}
fn as_bytes_mut(&mut self) -> &mut [u8] {
&mut self.0
}
fn from_bytes(bytes: &[u8]) -> Self {
Self(bytes.try_into().unwrap())
}
fn zeroed() -> Self {
Self([0; 24])
}
}
#[test]
fn tree_prefix_configuration_is_validated() {
for lengths in [&[][..], &[8], &[16], &[8, 16]] {
validate_prefix_filters::<TypedTreeKey>(lengths).unwrap();
}
for lengths in [&[0][..], &[24], &[7], &[16, 16]] {
assert!(matches!(
validate_prefix_filters::<TypedTreeKey>(lengths),
Err(DbError::Config(_))
));
}
validate_prefix_filters::<testkit::RawTestKey>(&[7, 13, 31]).unwrap();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("uncreated");
assert!(matches!(
testkit::try_open_tree_core(&path, SegConfig::test(), TestClock::new(1), &[0]),
Err(DbError::Config(_))
));
assert!(!path.exists());
}
#[test]
fn tree_order_mismatch_has_no_repair_or_cleanup() {
fn snapshot(dir: &Path) -> Vec<(PathBuf, Vec<u8>)> {
let mut out = Vec::new();
for entry in std::fs::read_dir(dir).unwrap() {
let entry = entry.unwrap();
if entry.file_type().unwrap().is_dir() {
out.extend(snapshot(&entry.path()));
} else if entry.file_name() != "db.lock" {
out.push((entry.path(), std::fs::read(entry.path()).unwrap()));
}
}
out.sort();
out
}
for tree in [false, true] {
let dir = tempfile::tempdir().unwrap();
let config = SegConfig::test();
let clock = TestClock::new(1_000);
let core = if tree {
testkit::open_tree_core(dir.path(), config.clone(), clock.clone(), &[])
} else {
open_core(dir.path(), config.clone())
};
core.put(&key_of(1), b"value").unwrap();
let journal = core.view().active.dir().join("shard_000/000001.data");
core.clean_shutdown().unwrap();
drop(core);
std::fs::OpenOptions::new()
.append(true)
.open(&journal)
.unwrap()
.write_all(b"repairable tail")
.unwrap();
std::fs::write(dir.path().join(MANIFEST_TMP), b"garbage manifest").unwrap();
std::fs::create_dir(dir.path().join("gen/unreferenced")).unwrap();
std::fs::write(
dir.path().join("gen/unreferenced/keep"),
b"garbage generation",
)
.unwrap();
let before = snapshot(dir.path());
let prefix_fs = TraceFs::new();
let invalid = SegCore::<testkit::TestKey>::open_tree(
dir.path(),
testkit::meta(),
&[0],
config.clone(),
OpenOptions {
fs: prefix_fs.clone(),
clock: clock.clock(),
worker: false,
},
);
assert!(matches!(invalid, Err(DbError::Config(_))));
assert!(prefix_fs.ops().is_empty());
assert_eq!(snapshot(dir.path()), before);
let fs = TraceFs::new();
let options = OpenOptions {
fs: fs.clone(),
clock: clock.clock(),
worker: false,
};
let result = if tree {
SegCore::<testkit::TestKey>::open(dir.path(), testkit::meta(), config, options)
} else {
SegCore::<testkit::TestKey>::open_tree(
dir.path(),
testkit::meta(),
&[],
config,
options,
)
};
assert!(matches!(result, Err(DbError::FormatMismatch(_))));
assert_eq!(snapshot(dir.path()), before);
assert!(
fs.ops()
.iter()
.all(|op| op.kind() == FsOpKind::CreateDirAll && op.target() == dir.path())
);
}
}
#[test]
fn tree_recovered_full_generation_preserves_admission() {
let dir = tempfile::tempdir().unwrap();
let config = SegConfig {
seal_max_keys: 3,
..SegConfig::test()
};
let core =
testkit::open_raw_tree_core(dir.path(), config.clone(), TestClock::new(1_000), &[8]);
for i in 0..3 {
core.put(&testkit::raw_ordered_key(i), b"v").unwrap();
}
let id = core.view().active.id();
core.clean_shutdown().unwrap();
drop(core);
let config = SegConfig {
shard_count: 8,
..config
};
let core = testkit::open_raw_tree_core(dir.path(), config, TestClock::new(2_000), &[16]);
assert_eq!(core.prefix_filters, [16]);
assert!(core.view().active.is_full());
assert_eq!(core.view().active.shard_count(), 2);
core.put(&testkit::raw_ordered_key(4), b"new").unwrap();
assert_ne!(core.view().active.id(), id);
assert_eq!(core.view().active.shard_count(), 8);
assert_eq!(core.view().frozen[0].id(), id);
assert_eq!(
core.get(&testkit::raw_ordered_key(4)).unwrap(),
Some(b"new".to_vec())
);
}
#[test]
fn physical_entries_count_tombstones_and_shadowed_versions() {
let dir = tempfile::tempdir().unwrap();
let core = testkit::open_tree_core(dir.path(), SegConfig::test(), TestClock::new(100), &[]);
let k = testkit::ordered_key(1);
core.put(&k, b"a").unwrap();
core.seal().unwrap();
core.seal_oldest().unwrap();
core.put(&k, b"b").unwrap();
core.delete(&testkit::ordered_key(2)).unwrap();
assert_eq!(core.physical_entries(), 3);
assert!(core.len() < 3 + 1);
}
}