use std::path::Path;
use std::sync::Arc;
use super::fs::SegFs;
use super::hash::{cmp_hk, key_hash};
use super::manifest::SegRecord;
use super::seal::{SegTimes, SegmentWriter};
use super::sidecar::{OrderKind, SegHeader};
use crate::codec::Codec;
use crate::entry::serialize_entry;
use crate::error::DbError;
pub(crate) const KEY_LEN: usize = 32;
pub(crate) const SEED: u64 = 0x5eed;
pub(crate) type TestKey = [u8; KEY_LEN];
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub(crate) struct RawTestKey(pub TestKey);
impl crate::key::Key for RawTestKey {
const KEY_SCHEME: armour_core::KeyScheme = armour_core::KeyScheme::Bytes;
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; KEY_LEN])
}
}
pub(crate) struct TestEntry {
pub h: u64,
pub key: TestKey,
pub value: Option<Vec<u8>>,
pub gsn: u64,
}
impl TestEntry {
pub(crate) fn bytes(&self) -> Vec<u8> {
match &self.value {
Some(v) => serialize_entry(self.gsn, &self.key, v, false),
None => serialize_entry(self.gsn, &self.key, &[], true),
}
}
}
pub(crate) fn key_of(i: u64) -> TestKey {
let mut key = [0u8; KEY_LEN];
for (n, chunk) in key.chunks_mut(8).enumerate() {
let word = i.wrapping_mul(0x9e37_79b9_7f4a_7c15).wrapping_add(n as u64);
chunk.copy_from_slice(&word.to_le_bytes());
}
key[..8].copy_from_slice(&i.to_le_bytes());
key
}
pub(crate) fn ordered_key(n: u64) -> TestKey {
let mut key = [0; KEY_LEN];
key[..8].copy_from_slice(&n.to_be_bytes());
key
}
pub(crate) fn ordered_entries(n: u64) -> Vec<TestEntry> {
(0..n)
.map(|i| {
let key = ordered_key(i);
TestEntry {
h: key_hash(&key, SEED),
key,
value: (i % 10 != 9).then(|| value_of(i)),
gsn: i + 1,
}
})
.collect()
}
pub(crate) fn write_segment_with_filter_bits(
seg_dir: &Path,
id: u64,
entries: &[TestEntry],
bits: u8,
) -> SegRecord {
let mut writer =
SegmentWriter::create(super::fs::real(), seg_dir, header(id), entries.len() as u64)
.unwrap();
writer.force_filter_bits(bits);
for entry in entries {
writer.push(entry.h, &entry.bytes()).unwrap();
}
writer.finish(times(), 0, 0).unwrap().into_record()
}
pub(crate) fn corrupt_section_everywhere(seg_dir: &Path, rec: &SegRecord, kind: u32) {
use super::sidecar::*;
let path = seg_dir.join(super::seal::sidx_name(rec.segment_id, rec.version));
let mut bytes = std::fs::read(&path).unwrap();
let footer = bytes.len() - SIDX_FOOTER_LEN;
let (at, count, crc) = parse_footer(&bytes[footer..], bytes.len() as u64).unwrap();
let records = parse_table(&bytes[at as usize..footer], count, crc, at).unwrap();
let section = records.iter().find(|r| r.kind == kind).unwrap();
for c in 0..super::page_index::chunk_count(section.offset, section.len) {
bytes[super::page_index::chunk_range(section.offset, section.len, c).0 as usize] ^= 1;
}
std::fs::write(path, bytes).unwrap();
}
pub(crate) fn raw_ordered_key(n: u64) -> RawTestKey {
RawTestKey(ordered_key(n))
}
pub(crate) fn value_of(i: u64) -> Vec<u8> {
format!("value-{i:08}").into_bytes()
}
pub(crate) fn entries(n: u64, first_gsn: u64) -> Vec<TestEntry> {
let mut out: Vec<TestEntry> = (0..n)
.map(|i| {
let key = key_of(i);
TestEntry {
h: key_hash(&key, SEED),
key,
value: (i % 10 != 9).then(|| value_of(i)),
gsn: first_gsn + i,
}
})
.collect();
out.sort_by(|a, b| cmp_hk(a.h, &a.key, b.h, &b.key));
out
}
pub(crate) fn header(segment_id: u64) -> SegHeader {
SegHeader {
segment_id,
version: 1,
order: OrderKind::ByHash,
key_len: KEY_LEN as u16,
seed: SEED,
block_size: 4 * 1024,
}
}
pub(crate) fn times() -> SegTimes {
SegTimes {
opened_at_ms: 1_000,
frozen_at_ms: 2_000,
sealed_at_ms: 3_000,
}
}
pub(crate) fn key_entries() -> Vec<TestEntry> {
(0..100)
.map(|n| {
let key = ordered_key(n);
TestEntry {
h: key_hash(&key, SEED),
key,
value: (n != 99).then(|| vec![42; 80]),
gsn: n + 1,
}
})
.collect()
}
pub(crate) fn write_key_segment(seg_dir: &Path, entries: &[TestEntry]) -> SegRecord {
let mut header = header(41);
header.order = OrderKind::ByKey;
header.block_size = 256;
let mut writer = SegmentWriter::create_key(
super::fs::real(),
seg_dir,
header,
&[4, 8],
entries.len() as u64,
)
.unwrap();
for entry in entries {
writer.push(entry.h, &entry.bytes()).unwrap();
}
writer.finish(times(), 0, 0).unwrap().into_record()
}
pub(crate) fn rewrite_section(
seg_dir: &Path,
rec: &SegRecord,
kind: u32,
mutate: impl FnOnce(&mut Vec<u8>),
) -> SegRecord {
rewrite_sections(seg_dir, rec, |sections| {
mutate(&mut sections.iter_mut().find(|(k, _)| *k == kind).unwrap().1);
})
}
pub(crate) fn rewrite_key_section(
seg_dir: &Path,
rec: &SegRecord,
kind: u32,
mutate: impl FnOnce(&mut Vec<u8>),
) -> SegRecord {
rewrite_section(seg_dir, rec, kind, mutate)
}
pub(crate) fn rewrite_sections(
seg_dir: &Path,
rec: &SegRecord,
mutate: impl FnOnce(&mut Vec<(u32, Vec<u8>)>),
) -> SegRecord {
use super::sidecar::*;
let path = seg_dir.join(super::seal::sidx_name(rec.segment_id, rec.version));
let bytes = std::fs::read(&path).unwrap();
let footer = bytes.len() - SIDX_FOOTER_LEN;
let (table_at, count, crc) = parse_footer(&bytes[footer..], bytes.len() as u64).unwrap();
let table = parse_table(&bytes[table_at as usize..footer], count, crc, table_at).unwrap();
let mut sections: Vec<_> = table
.iter()
.map(|r| {
(
r.kind,
bytes[r.offset as usize..(r.offset + r.len) as usize].to_vec(),
)
})
.collect();
mutate(&mut sections);
let header = SegHeader::decode(&bytes[..FILE_HEADER_LEN], SIDX_MAGIC).unwrap();
let bytes = encode_sidecar(&header, §ions);
std::fs::write(path, &bytes).unwrap();
let mut rec = rec.clone();
rec.sidx_len = bytes.len() as u64;
rec.sidx_checksum = xxhash_rust::xxh3::xxh3_64(&bytes);
rec
}
pub(crate) fn write_segment(
fs: Arc<dyn SegFs>,
seg_dir: &Path,
segment_id: u64,
entries: &[TestEntry],
) -> SegRecord {
write(fs, seg_dir, segment_id, entries, false)
}
pub(crate) fn write_legacy_segment(
fs: Arc<dyn SegFs>,
seg_dir: &Path,
segment_id: u64,
entries: &[TestEntry],
) -> SegRecord {
let rec = write_segment(fs, seg_dir, segment_id, entries);
without_page_index(seg_dir, &rec)
}
pub(crate) fn write_legacy_key_segment(seg_dir: &Path, entries: &[TestEntry]) -> SegRecord {
let rec = write_key_segment(seg_dir, entries);
without_page_index(seg_dir, &rec)
}
fn without_page_index(seg_dir: &Path, rec: &SegRecord) -> SegRecord {
rewrite_sections(seg_dir, rec, |sections| {
sections.retain(|(kind, _)| *kind != super::sidecar::SECTION_PAGE_INDEX);
})
}
pub(crate) fn write_segment_with_staged_hashes(
fs: Arc<dyn SegFs>,
seg_dir: &Path,
segment_id: u64,
entries: &[TestEntry],
) -> SegRecord {
write(fs, seg_dir, segment_id, entries, true)
}
fn write(
fs: Arc<dyn SegFs>,
seg_dir: &Path,
segment_id: u64,
entries: &[TestEntry],
staged_hashes: bool,
) -> SegRecord {
let mut writer =
SegmentWriter::create(fs, seg_dir, header(segment_id), entries.len() as u64).unwrap();
if staged_hashes {
writer.trust_caller_hash();
}
for e in entries {
writer.push(e.h, &e.bytes()).unwrap();
}
writer.finish(times(), 3, 0xcafe).unwrap().into_record()
}
use std::sync::atomic::{AtomicU64, Ordering};
use super::config::SegConfig;
use super::core::{Clock, OpenOptions, SegCore, SegMeta, create_layout};
use super::fs::real;
use super::generation::{GEN_DIR, Generation};
use super::manifest::{GenRecord, GenState, Manifest, publish};
use super::seal::SEG_DIR;
use crate::error::DbResult;
use crate::seg::config::Limits;
pub(crate) fn meta() -> SegMeta {
SegMeta {
name: "test_seg",
typ_hash: 0xcafe,
value_version: 3,
}
}
#[derive(Clone)]
pub(crate) struct TestClock(Arc<AtomicU64>);
impl TestClock {
pub(crate) fn new(now_ms: u64) -> Self {
Self(Arc::new(AtomicU64::new(now_ms)))
}
pub(crate) fn set(&self, now_ms: u64) {
self.0.store(now_ms, Ordering::SeqCst);
}
pub(crate) fn advance(&self, ms: u64) {
self.0.fetch_add(ms, Ordering::SeqCst);
}
pub(crate) fn clock(&self) -> Clock {
let now = self.0.clone();
Arc::new(move || now.load(Ordering::SeqCst))
}
}
pub(crate) fn try_open_core(
dir: &Path,
config: SegConfig,
fs: Arc<dyn SegFs>,
clock: &TestClock,
) -> DbResult<Arc<SegCore<TestKey>>> {
SegCore::open(
dir,
meta(),
config,
OpenOptions {
fs,
clock: clock.clock(),
worker: false,
},
)
}
pub(crate) fn open_core(dir: &Path, config: SegConfig) -> Arc<SegCore<TestKey>> {
try_open_core(dir, config, real(), &TestClock::new(1_000_000)).unwrap()
}
pub(crate) fn try_open_tree_core(
path: &Path,
config: SegConfig,
clock: TestClock,
prefix_filters: &'static [usize],
) -> DbResult<Arc<SegCore<TestKey>>> {
SegCore::open_tree(
path,
meta(),
prefix_filters,
config,
OpenOptions {
fs: real(),
clock: clock.clock(),
worker: false,
},
)
}
pub(crate) fn open_tree_core(
path: &Path,
config: SegConfig,
clock: TestClock,
prefix_filters: &'static [usize],
) -> Arc<SegCore<TestKey>> {
try_open_tree_core(path, config, clock, prefix_filters).unwrap()
}
pub(crate) fn try_open_raw_tree_core(
path: &Path,
config: SegConfig,
clock: TestClock,
prefix_filters: &'static [usize],
) -> DbResult<Arc<SegCore<RawTestKey>>> {
SegCore::open_tree(
path,
meta(),
prefix_filters,
config,
OpenOptions {
fs: real(),
clock: clock.clock(),
worker: false,
},
)
}
pub(crate) fn open_raw_tree_core(
path: &Path,
config: SegConfig,
clock: TestClock,
prefix_filters: &'static [usize],
) -> Arc<SegCore<RawTestKey>> {
try_open_raw_tree_core(path, config, clock, prefix_filters).unwrap()
}
const ROOMY: Limits = Limits {
max_keys: u64::MAX,
max_bytes: u64::MAX,
};
fn fill(g: &Generation<TestKey>, keys: std::ops::Range<u64>, deleted: u64, tag: &str) {
for i in keys.clone() {
let key = key_of(i);
let h = key_hash(&key, SEED);
let value = format!("{tag}-{i}");
let value = (i >= keys.start + deleted).then_some(value.as_bytes());
g.append(h, &key, value, ROOMY).unwrap();
}
g.write_hints().unwrap();
g.close().unwrap();
}
pub(crate) fn build_collection(dir: &Path) {
build_collection_shape(dir, CoreShape::ByHash);
}
pub(crate) fn build_collection_shape(dir: &Path, shape: CoreShape) {
let fs = real();
create_layout(&*fs, dir).unwrap();
let gen_root = dir.join(GEN_DIR);
let seg_root = dir.join(SEG_DIR);
let config = SegConfig::test();
let mut segment = entries(200, 1);
if matches!(shape, CoreShape::ByKey) {
segment.sort_by_key(|entry| entry.key);
}
let mut manifest = Manifest::new(KEY_LEN as u16, SEED, 1);
manifest.order = shape.order();
manifest.next_segment_id = 2;
manifest.next_gen_id = 3;
manifest.gsn_floor = 350;
manifest.segments.push(match shape {
CoreShape::ByHash => write_segment(fs.clone(), &seg_root, 1, &segment),
CoreShape::ByKey => {
let mut h = header(1);
h.order = OrderKind::ByKey;
let mut writer =
SegmentWriter::create_key(fs.clone(), &seg_root, h, &[], segment.len() as u64)
.unwrap();
for entry in &segment {
writer.push(entry.h, &entry.bytes()).unwrap();
}
writer.finish(times(), 0, 0).unwrap().into_record()
}
});
let frozen: Generation<TestKey> =
Generation::create(fs.clone(), &gen_root, 1, &config, 2_500, shape.order()).unwrap();
frozen.seed_gsn(201);
fill(&frozen, 100..250, 10, "frozen");
manifest.generations.push(GenRecord {
gen_id: 1,
state: GenState::Frozen,
shard_count: config.shard_count as u8,
opened_at_ms: 2_500,
frozen_at_ms: 3_000,
min_gsn: 201,
max_gsn: 350,
});
let active: Generation<TestKey> =
Generation::create(fs.clone(), &gen_root, 2, &config, 3_000, shape.order()).unwrap();
active.seed_gsn(351);
fill(&active, 200..300, 10, "active");
manifest.generations.push(GenRecord {
gen_id: 2,
state: GenState::Active,
shard_count: config.shard_count as u8,
opened_at_ms: 3_000,
frozen_at_ms: 0,
min_gsn: 351,
max_gsn: 0,
});
manifest.check().unwrap();
publish(&*fs, dir, &manifest).unwrap();
}
pub(crate) fn build_legacy_collection(dir: &Path, segments: u64) {
let fs = real();
create_layout(&*fs, dir).unwrap();
let config = SegConfig::test();
let mut manifest = Manifest::new(KEY_LEN as u16, SEED, 1);
for id in 1..=segments {
let key = key_of(id);
let entries = [TestEntry {
h: key_hash(&key, SEED),
key,
value: Some(value_of(id)),
gsn: id,
}];
let rec = write_legacy_segment(fs.clone(), &dir.join(SEG_DIR), id, &entries);
manifest.segments.push(rec);
}
manifest.next_segment_id = segments + 1;
manifest.next_gen_id = 2;
manifest.gsn_floor = segments;
let active: Generation<TestKey> = Generation::create(
fs.clone(),
&dir.join(GEN_DIR),
1,
&config,
2000,
OrderKind::ByHash,
)
.unwrap();
active.seed_gsn(segments + 1);
manifest.generations.push(GenRecord {
gen_id: 1,
state: GenState::Active,
shard_count: config.shard_count as u8,
opened_at_ms: 2000,
frozen_at_ms: 0,
min_gsn: segments + 1,
max_gsn: 0,
});
manifest.check().unwrap();
publish(&*fs, dir, &manifest).unwrap();
}
pub(crate) struct Running(pub Arc<SegCore<TestKey>>);
impl std::ops::Deref for Running {
type Target = SegCore<TestKey>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl Drop for Running {
fn drop(&mut self) {
self.0.stop_worker();
}
}
pub(crate) fn open_core_with_worker(dir: &Path, config: SegConfig) -> Running {
Running(SegCore::open(dir, meta(), config, OpenOptions::production()).unwrap())
}
pub(crate) fn value(i: u64) -> Vec<u8> {
format!("v{i}").into_bytes()
}
pub(crate) fn fill_core(core: &SegCore<TestKey>, keys: std::ops::Range<u64>) {
for i in keys {
core.put(&key_of(i), &value(i)).unwrap();
}
}
pub(crate) fn copy_collection(from: &Path, to: &Path) {
std::fs::create_dir_all(to).unwrap();
for entry in std::fs::read_dir(from).unwrap() {
let entry = entry.unwrap();
let target = to.join(entry.file_name());
if entry.file_type().unwrap().is_dir() {
copy_collection(&entry.path(), &target);
} else if entry.file_name() != "db.lock" {
std::fs::copy(entry.path(), target).unwrap();
}
}
}
#[derive(Clone, Default)]
pub(crate) struct TextCodec;
impl Codec<String> for TextCodec {
fn encode_to(&self, value: &String, buf: &mut Vec<u8>) -> DbResult<()> {
buf.clear();
buf.extend_from_slice(value.as_bytes());
Ok(())
}
fn decode_from(&self, bytes: &[u8]) -> DbResult<String> {
String::from_utf8(bytes.to_vec()).map_err(|_| DbError::CorruptedEntry { offset: 0 })
}
}
pub(crate) struct UnreadableJournals(Vec<(std::path::PathBuf, Vec<u8>)>);
impl UnreadableJournals {
pub(crate) fn new(root: &Path) -> Self {
fn damage(dir: &Path, saved: &mut Vec<(std::path::PathBuf, Vec<u8>)>) {
for entry in std::fs::read_dir(dir).unwrap() {
let path = entry.unwrap().path();
if path.is_dir() {
damage(&path, saved);
} else if path.extension().is_some_and(|ext| ext == "data") {
saved.push((path.clone(), std::fs::read(&path).unwrap()));
std::fs::OpenOptions::new()
.write(true)
.open(&path)
.unwrap()
.set_len(0)
.unwrap();
}
}
}
let mut saved = Vec::new();
damage(&root.join(GEN_DIR), &mut saved);
assert!(saved.iter().any(|(_, bytes)| !bytes.is_empty()));
Self(saved)
}
}
impl Drop for UnreadableJournals {
fn drop(&mut self) {
for (path, bytes) in &self.0 {
std::fs::write(path, bytes).unwrap();
}
}
}
#[derive(Clone, Copy)]
pub(crate) enum CoreShape {
ByHash,
ByKey,
}
impl CoreShape {
pub(crate) fn order(self) -> OrderKind {
match self {
Self::ByHash => OrderKind::ByHash,
Self::ByKey => OrderKind::ByKey,
}
}
pub(crate) fn try_open_core(
self,
dir: &Path,
config: SegConfig,
fs: Arc<dyn SegFs>,
clock: &TestClock,
) -> DbResult<Arc<SegCore<TestKey>>> {
match self {
Self::ByHash => try_open_core(dir, config, fs, clock),
Self::ByKey => SegCore::open_tree(
dir,
meta(),
&[],
config,
OpenOptions {
fs,
clock: clock.clock(),
worker: false,
},
),
}
}
pub(crate) fn open_core(self, dir: &Path, config: SegConfig) -> Arc<SegCore<TestKey>> {
self.try_open_core(dir, config, real(), &TestClock::new(1_000_000))
.unwrap()
}
pub(crate) fn build_collection(self, dir: &Path) {
build_collection_shape(dir, self);
}
}
pub(crate) fn corrupt_prefix_fingerprints(seg_dir: &Path, rec: &SegRecord, prefix_len: u16) {
use super::sidecar::*;
let path = seg_dir.join(super::seal::sidx_name(rec.segment_id, rec.version));
let mut bytes = std::fs::read(&path).unwrap();
let footer = bytes.len() - SIDX_FOOTER_LEN;
let (at, count, crc) = parse_footer(&bytes[footer..], bytes.len() as u64).unwrap();
let records = parse_table(&bytes[at as usize..footer], count, crc, at).unwrap();
let section = records
.iter()
.find(|r| {
r.kind == SECTION_PREFIX_FILTER
&& u16::from_le_bytes(
bytes[r.offset as usize..r.offset as usize + 2]
.try_into()
.unwrap(),
) == prefix_len
})
.unwrap();
let filter_at = section.offset as usize + 8;
let partitions =
u32::from_le_bytes(bytes[filter_at + 4..filter_at + 8].try_into().unwrap()) as usize;
let fingerprints_at = filter_at + 8 + partitions * 32;
assert!(fingerprints_at < (section.offset + section.len) as usize);
bytes[fingerprints_at] ^= 1;
std::fs::write(path, bytes).unwrap();
}