#![cfg(any(windows, target_os = "linux", target_os = "macos"))]
#![allow(
clippy::unwrap_used,
clippy::expect_used,
unused_results,
unused_must_use
)]
use std::ops::ControlFlow;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicU32, Ordering};
use store_io::{
Directory, DurabilityClass, Error, ReceiptLabel, ScanItem, Store, StoreOptions, Trust,
};
struct TempDir(PathBuf);
impl TempDir {
fn new(tag: &str) -> Self {
static N: AtomicU32 = AtomicU32::new(0);
let base = std::env::var_os("STORE_IO_TEST_DIR")
.or_else(|| std::env::var_os("HOME").filter(|_| cfg!(target_os = "linux")))
.map_or_else(std::env::temp_dir, PathBuf::from);
let d = base.join(format!(
".store-io-native-{}-{}-{tag}",
std::process::id(),
N.fetch_add(1, Ordering::Relaxed)
));
std::fs::create_dir_all(&d).unwrap();
Self(d)
}
fn path(&self) -> &Path {
&self.0
}
}
impl Drop for TempDir {
fn drop(&mut self) {
let _cleanup = std::fs::remove_dir_all(&self.0);
}
}
fn options_for(dir: &Path) -> (StoreOptions, bool) {
let probe = store_io::probe(dir).unwrap();
let refused = !matches!(probe.decision.durable_open, store_io::DurableOpen::Allowed);
let opts = StoreOptions {
trust: Trust {
override_refusal: refused,
..Trust::default()
},
..StoreOptions::default()
};
(opts, refused)
}
#[test]
fn test_store_round_trip_on_the_real_file_system() {
let t = TempDir::new("store");
let (opts, overridden) = options_for(t.path());
let path = t.path().join("orders");
let store = Store::create(&path, opts.clone()).unwrap();
let class = store.report().decision.class;
if class == DurabilityClass::Unsafe {
assert!(overridden, "an unsafe store opened without the override");
}
let wal = store.provision_append_region("wal", 8 << 20).unwrap();
let (pos, receipt) = wal.append_durable(b"order 1001").unwrap();
assert_eq!(receipt.class(), class);
assert_eq!(
matches!(receipt.label(), ReceiptLabel::Overridden(_)),
overridden
);
let mut batch = wal.batch();
for i in 0..100u32 {
batch
.append(format!("order {}", 2000 + i).as_bytes())
.unwrap();
}
let (bpos, _) = batch.commit().unwrap();
let big: Vec<u8> = (0..3_000_000u32).map(|i| (i % 251) as u8).collect();
let (big_pos, _) = wal.append_durable(&big).unwrap();
let pages = store.provision_page_region("pages", 1 << 20).unwrap();
let bs = pages.block_size() as usize;
pages
.write_durable(pages.pos(0).unwrap(), &vec![7u8; bs])
.unwrap();
let manifest = store.provision_slot("manifest").unwrap();
manifest.commit(b"wal@0").unwrap();
let mut reservation = store.reserve(2 << 20, 9).unwrap();
reservation
.provision_page_region("tenant9", 1 << 20)
.unwrap();
drop((reservation, batch, wal, pages, manifest, store));
let ro = Store::open_readonly(&path).unwrap();
let wal = ro.append_region("wal").unwrap();
let mut first = vec![0u8; 10];
wal.read(pos.offset(), &mut first).unwrap();
assert_eq!(&first, b"order 1001");
let mut seen = Vec::new();
let summary = wal
.scan(0, |item| {
if let ScanItem::Data { offset, bytes } = item {
seen.push((offset, bytes.len()));
}
ControlFlow::Continue(())
})
.unwrap();
assert_eq!(summary.unreadable, 0);
assert_eq!(summary.end, wal.len());
let mut back = vec![0u8; big.len()];
wal.read(big_pos.offset(), &mut back).unwrap();
assert!(back == big, "large append round trip");
let mut rec = vec![0u8; 10];
wal.read(bpos.offset(), &mut rec).unwrap();
assert_eq!(&rec, b"order 2000");
assert!(matches!(wal.append(b"x"), Err(Error::NotWritten { .. })));
drop((wal, ro));
let store = Store::open_with(&path, opts).unwrap();
assert_eq!(store.slot("manifest").unwrap().read().unwrap(), b"wal@0");
let wal = store.append_region("wal").unwrap();
assert!(matches!(wal.append(b"x"), Err(Error::NotWritten { .. })));
let end = big_pos.offset() + big.len() as u64;
wal.resume_at(end).unwrap();
let (next, _) = wal.append_durable(b"after reopen").unwrap();
assert!(next.offset() >= end);
assert!(
store
.space()
.tags
.iter()
.any(|t| t.tag == 9 && t.physical > 0)
);
assert!(matches!(Store::open(&path), Err(Error::Locked)));
}
#[test]
fn test_directory_replace_on_the_real_file_system() {
let t = TempDir::new("dir");
let (opts, _) = options_for(t.path());
let dir = Directory::open_with(t.path().join("meta"), true, opts.trust).unwrap();
for (i, len) in [0usize, 15, 4096, 10_000].into_iter().enumerate() {
let data: Vec<u8> = (0..len).map(|j| (i + j) as u8).collect();
dir.replace("CURRENT", &data).unwrap();
assert_eq!(dir.read("CURRENT").unwrap(), data);
assert_eq!(
std::fs::read(t.path().join("meta").join("CURRENT")).unwrap(),
data
);
}
dir.remove("CURRENT").unwrap();
assert!(matches!(dir.read("CURRENT"), Err(Error::NotFound { .. })));
assert!(dir.class().is_some());
}
#[test]
fn test_releasing_a_region_leaves_its_neighbours_and_the_metadata_intact() {
let t = TempDir::new("release");
let (opts, _overridden) = options_for(t.path());
let path = t.path().join("columns");
let store = Store::create(&path, opts.clone()).unwrap();
let fill =
|tag: u8, len: usize| -> Vec<u8> { (0..len).map(|i| tag ^ (i % 253) as u8).collect() };
let size = 1u64 << 20;
let names = ["left", "middle", "right"];
for (i, name) in names.iter().enumerate() {
let r = store.provision_page_region(name, size).unwrap();
r.write_durable(r.pos(0).unwrap(), &fill(i as u8 + 1, size as usize))
.unwrap();
}
let manifest = store.provision_slot("manifest").unwrap();
manifest.commit(b"left,middle,right").unwrap();
let container = path.join(store_io::CONTAINER);
let len_before = std::fs::metadata(&container).unwrap().len();
store.page_region("middle").unwrap().release().unwrap();
let check = |s: &Store| {
for (i, name) in names.iter().enumerate().filter(|(_, n)| **n != "middle") {
let r = s.page_region(name).unwrap();
let mut back = vec![0u8; size as usize];
r.read(r.pos(0).unwrap(), &mut back).unwrap();
assert!(back == fill(i as u8 + 1, size as usize), "{name} changed");
}
assert!(matches!(
s.page_region("middle"),
Err(Error::NotFound { .. })
));
assert_eq!(
s.slot("manifest").unwrap().read().unwrap(),
b"left,middle,right"
);
assert!(s.unavailable_regions().is_empty());
};
check(&store);
assert_eq!(std::fs::metadata(&container).unwrap().len(), len_before);
#[cfg(windows)]
{
use std::os::windows::fs::MetadataExt;
const FILE_ATTRIBUTE_SPARSE_FILE: u32 = 0x200;
let attrs = std::fs::metadata(&container).unwrap().file_attributes();
assert_eq!(
attrs & FILE_ATTRIBUTE_SPARSE_FILE,
0,
"the container became sparse"
);
}
drop((manifest, store));
let store = Store::open_with(&path, opts).unwrap();
check(&store);
let again = store.provision_page_region("again", size).unwrap();
let data = fill(9, size as usize);
again.write_durable(again.pos(0).unwrap(), &data).unwrap();
let mut back = vec![0u8; size as usize];
again.read(again.pos(0).unwrap(), &mut back).unwrap();
assert!(back == data, "the reused space did not read back");
check(&store);
}
#[test]
fn test_a_write_protected_store_opens_read_only_for_two_readers() {
let t = TempDir::new("ro");
let (opts, _overridden) = options_for(t.path());
let path = t.path().join("backup");
let store = Store::create(&path, opts).unwrap();
let wal = store.provision_append_region("wal", 1 << 20).unwrap();
let (pos, _) = wal.append_durable(b"kept in the backup").unwrap();
drop((wal, store));
let container = path.join(store_io::CONTAINER);
let set_read_only = |on: bool| {
let mut perms = std::fs::metadata(&container).unwrap().permissions();
#[allow(clippy::permissions_set_readonly_false)]
perms.set_readonly(on);
std::fs::set_permissions(&container, perms).unwrap();
};
set_read_only(true);
let first = Store::open_readonly(&path);
let second = Store::open_readonly(&path);
let writable = Store::open(&path);
set_read_only(false);
let (first, second) = (first.unwrap(), second.unwrap());
for s in [&first, &second] {
let mut out = vec![0u8; 18];
s.append_region("wal")
.unwrap()
.read(pos.offset(), &mut out)
.unwrap();
assert_eq!(out, b"kept in the backup");
}
if cfg!(windows) {
assert!(writable.is_err(), "a writable open of a read-only file");
}
}
#[test]
fn test_the_coarse_clock_advances_with_real_time() {
use store_io_platform::Platform;
let p = store_io::NativePlatform::new();
let t0 = p.monotonic_ms();
std::thread::sleep(std::time::Duration::from_millis(250));
let t1 = p.monotonic_ms();
let moved = t1.wrapping_sub(t0);
assert!(
t1 >= t0 + 200,
"the clock advanced only {moved} ms in 250 ms"
);
assert!(moved < 10_000, "the clock jumped {moved} ms in 250 ms");
}
#[test]
fn test_parallel_page_batches_and_large_reads_round_trip() {
let t = TempDir::new("parallel");
let (opts, _) = options_for(t.path());
let opts = StoreOptions {
t3_pool_threads: 3,
..opts
};
let store = Store::create(t.path().join("pages"), opts).unwrap();
let pages = store.provision_page_region("pages", 16 << 20).unwrap();
let bs = pages.block_size() as usize;
let page = |round: u8, i: usize| -> Vec<u8> {
(0..bs)
.map(|k| (k as u8) ^ (i as u8).wrapping_mul(31) ^ round)
.collect()
};
let stride = (8 << 20) / 48 / bs * bs;
let mut one = pages.batch();
one.write(pages.pos(0).unwrap(), &page(0, 0)).unwrap();
one.commit().unwrap();
assert_eq!(
store.submit_pool_threads(),
None,
"a one-write batch started the pool"
);
for round in 1..=3u8 {
let mut batch = pages.batch();
for i in (0..48).rev() {
batch
.write(pages.pos((i * stride) as u64).unwrap(), &page(round, i))
.unwrap();
}
batch.commit().unwrap();
let mut back = vec![0u8; 8 << 20];
assert_eq!(
pages.read(pages.pos(0).unwrap(), &mut back).unwrap(),
back.len()
);
for i in 0..48 {
let at = i * stride;
assert!(
back[at..at + bs] == page(round, i),
"round {round}: block {i} differs"
);
}
}
if store.report().io.interface == store_io::IoInterface::Synchronous {
assert_eq!(store.submit_pool_threads(), Some(3));
} else {
assert_eq!(store.submit_pool_threads(), None);
}
assert_eq!(store.oldest_outstanding(), None);
}
#[test]
fn test_submitter_round_trips_on_the_real_file_system() {
use store_io::submit::{Done, SubmitterConfig};
let full = |e: &Error| {
matches!(
e,
Error::NotWritten {
cause: store_io::NotWrittenCause::QueueFull,
..
}
)
};
let t = TempDir::new("submitter");
let (opts, _) = options_for(t.path());
let store = Store::create(t.path().join("sub"), opts).unwrap();
let wal = store.provision_append_region("wal", 16 << 20).unwrap();
let pages = store.provision_page_region("pages", 16 << 20).unwrap();
let bs = pages.block_size() as usize;
let record = |i: u64, len: usize| -> Vec<u8> {
(0..len)
.map(|k| (k as u8).wrapping_mul(13) ^ (i as u8).wrapping_mul(29) ^ 0xA5)
.collect()
};
let mut sub = store
.submitter(SubmitterConfig::default().with_depth(32))
.unwrap();
let mut placed = Vec::new();
let mut done = Vec::new();
for i in 0..64u64 {
let len = 1 + (i as usize * 1531) % (3 * bs);
let mut buf = sub.take_buf(len).unwrap();
buf.as_mut_slice().copy_from_slice(&record(i, len));
let at = loop {
match sub.append(&wal, buf, store_io::submit::WriteMode::Plain, i) {
Ok(pos) => break pos.offset(),
Err(r) => {
assert!(full(&r.error), "{:?}", r.error);
buf = r.buf.unwrap();
done.extend(sub.wait(1).unwrap());
}
}
};
placed.push((at, len));
let mut page = sub.take_buf(bs).unwrap();
page.as_mut_slice().copy_from_slice(&record(1000 + i, bs));
let pos = pages.pos(i * 3 * bs as u64).unwrap();
while let Err(r) = sub.write(
&pages,
pos,
page,
store_io::submit::WriteMode::Plain,
1000 + i,
) {
assert!(full(&r.error), "{:?}", r.error);
page = r.buf.unwrap();
done.extend(sub.wait(1).unwrap());
}
}
while sub.in_flight() > 0 {
done.extend(sub.wait(sub.in_flight()).unwrap());
}
done.extend(sub.reap());
assert_eq!(done.len(), 128);
let mut last = None;
for c in done {
let Ok(Done::Written(w)) = c.outcome else {
panic!("operation {} failed: {:?}", c.tag, c.outcome);
};
if c.tag >= 1000 {
assert_eq!(w.ticket.pos().offset(), (c.tag - 1000) * 3 * bs as u64);
pages.sync_through(&w.ticket).unwrap();
} else {
assert_eq!(w.ticket.pos().offset(), placed[c.tag as usize].0);
if c.tag == 63 {
last = Some(w.ticket);
}
}
}
wal.sync_through(&last.unwrap()).unwrap();
for (i, &(at, len)) in placed.iter().enumerate() {
let buf = sub.take_buf(len.div_ceil(bs) * bs).unwrap();
sub.read_append(&wal, at, buf, i as u64).unwrap();
let buf = sub.take_buf(bs).unwrap();
let pos = pages.pos(i as u64 * 3 * bs as u64).unwrap();
sub.read_page(&pages, pos, buf, 1000 + i as u64).unwrap();
for c in sub.wait(2).unwrap() {
let Ok(Done::Read { len: n }) = c.outcome else {
panic!("read {} failed: {:?}", c.tag, c.outcome);
};
let got = c.buf.unwrap();
if c.tag >= 1000 {
assert_eq!(n, bs);
assert!(got.as_slice() == record(c.tag, bs), "page {i} differs");
} else {
assert!(
got.as_slice()[..len] == record(i as u64, len),
"append {i} differs"
);
assert!(got.as_slice()[len..].iter().all(|&b| b == 0));
}
}
}
assert_eq!(sub.in_flight(), 0);
drop(sub);
assert_eq!(store.oldest_outstanding(), None);
}
#[test]
fn test_durable_submitter_writes_on_the_real_file_system() {
use store_io::submit::{Done, SubmitterConfig, WriteMode};
let t = TempDir::new("durable");
let (opts, _) = options_for(t.path());
let store = Store::create(t.path().join("d"), opts).unwrap();
let wal = store.provision_append_region("wal", 8 << 20).unwrap();
let pages = store.provision_page_region("pages", 8 << 20).unwrap();
let bs = pages.block_size() as usize;
let mut sub = store
.submitter(SubmitterConfig::default().with_depth(128))
.unwrap();
let mut done = Vec::new();
for i in 0..32u64 {
let mut buf = sub.take_buf(300 + i as usize).unwrap();
buf.as_mut_slice().fill(i as u8);
sub.append(&wal, buf, WriteMode::Durable, i).unwrap();
let buf = sub.take_buf(bs).unwrap();
sub.read_page(&pages, pages.pos(0).unwrap(), buf, 1000 + i)
.unwrap();
}
sub.barrier_all(5000).unwrap();
while sub.in_flight() > 0 {
done.extend(sub.wait(1).unwrap());
}
done.extend(sub.reap());
assert_eq!(done.len(), 65);
for c in done {
match (c.tag, c.outcome) {
(5000, Ok(Done::Flushed)) => {}
(t, Ok(Done::Read { .. })) if t >= 1000 => {}
(t, Ok(Done::Written(w))) if t < 32 => {
assert!(w.receipt.unwrap().covers(&w.ticket), "write {t}");
}
(t, other) => panic!("operation {t}: {other:?}"),
}
}
drop(sub);
assert_eq!(store.oldest_outstanding(), None);
}
#[test]
fn test_a_4_mib_submitter_append_on_the_real_file_system() {
use store_io::submit::{Done, SubmitterConfig, WriteMode};
let t = TempDir::new("large");
let (opts, _) = options_for(t.path());
let store = Store::create(t.path().join("l"), opts).unwrap();
let wal = store.provision_append_region("wal", 16 << 20).unwrap();
let mut sub = store.submitter(SubmitterConfig::default()).unwrap();
let len = sub.max_buf();
assert_eq!(len, 4 << 20);
let bytes: Vec<u8> = (0..len).map(|k| (k as u8) ^ (k >> 13) as u8).collect();
let mut buf = sub.take_buf(len).unwrap();
buf.as_mut_slice().copy_from_slice(&bytes);
let at = sub
.append(&wal, buf, WriteMode::Durable, 1)
.unwrap()
.offset();
let c = sub.wait(1).unwrap().next().unwrap();
let Ok(Done::Written(w)) = c.outcome else {
panic!("{:?}", c.outcome)
};
assert!(w.receipt.unwrap().covers(&w.ticket));
let buf = sub.take_buf(len).unwrap();
sub.read_append(&wal, at, buf, 2).unwrap();
let c = sub.wait(1).unwrap().next().unwrap();
assert!(
c.buf.unwrap().as_slice() == bytes,
"4 MiB read back differs"
);
}
#[test]
fn test_the_io_tier_is_chosen_and_reported() {
use store_io::{IoInterface, LinuxTier, Op};
let t = TempDir::new("tier");
let (opts, _) = options_for(t.path());
let at = |tier| StoreOptions {
linux_tier: tier,
queues: 2,
..opts.clone()
};
let path = t.path().join("tiers");
let store = Store::create(&path, at(LinuxTier::Sync)).unwrap();
let io = store.report().io.clone();
let line = format!("io {} ({})", io.interface, io.reason);
assert!(store.report().to_string().contains(&line));
let wal = store.provision_append_region("wal", 1 << 20).unwrap();
let ticket = wal.append(b"written on one tier").unwrap();
wal.sync_through(&ticket).unwrap();
drop((wal, store));
if cfg!(windows) {
assert_eq!(io.interface, IoInterface::Iocp);
return;
}
if cfg!(target_os = "macos") {
assert_eq!(io.interface, IoInterface::Synchronous);
return;
}
assert_eq!(
(io.interface, io.reason.as_str()),
(IoInterface::Synchronous, "chosen")
);
let auto = Store::open_with(&path, at(LinuxTier::Auto)).unwrap();
let sub = auto
.submitter(store_io::submit::SubmitterConfig::default())
.unwrap();
let auto_io = auto.io_path();
drop(sub);
let wal = auto.append_region("wal").unwrap();
let mut back = vec![0u8; 19];
wal.read(ticket.pos().offset(), &mut back).unwrap();
assert_eq!(back, b"written on one tier");
drop((wal, auto));
let ro = Store::open_readonly_with(&path, at(LinuxTier::Sync)).unwrap();
assert_eq!(ro.report().io.interface, IoInterface::Synchronous);
drop(ro);
match Store::open_with(&path, at(LinuxTier::Uring)) {
Ok(s) => {
assert_eq!(s.report().io.interface, IoInterface::IoUring);
assert_eq!(auto_io.interface, IoInterface::IoUring);
assert!(auto_io.reason.starts_with("auto"), "{auto_io:?}");
assert!(!auto_io.reason.contains("synchronous"), "{auto_io:?}");
}
Err(Error::Io { op: Op::Queue, .. }) => {
assert!(
std::env::var_os("STORE_IO_EXPECT_URING").is_none(),
"io_uring refused where STORE_IO_EXPECT_URING says it works"
);
assert_eq!(auto_io.interface, IoInterface::Synchronous);
assert!(auto_io.reason.contains("io_uring refused"), "{auto_io:?}");
}
Err(e) => panic!("{e}"),
}
}
#[cfg(target_os = "linux")]
#[test]
fn test_a_registered_file_round_trips_and_is_reported() {
use store_io::LinuxTier;
use store_io::submit::{Done, SubmitterConfig, WriteMode};
let t = TempDir::new("registered");
let (opts, _) = options_for(t.path());
for on in [true, false] {
let opts = StoreOptions {
linux_tier: LinuxTier::Uring,
register_file: on,
..opts.clone()
};
let store = match Store::create(t.path().join(format!("s-{on}")), opts) {
Ok(s) => s,
Err(e) => {
assert!(
std::env::var_os("STORE_IO_EXPECT_URING").is_none(),
"io_uring refused ({e}) where STORE_IO_EXPECT_URING says it works"
);
return;
}
};
let pages = store.provision_page_region("p", 1 << 20).unwrap();
let mut sub = store
.submitter(SubmitterConfig::default().with_depth(4))
.unwrap();
let path = store.io_path();
if on {
assert!(
path.reason.contains("asked on 1 ring(s)")
&& path.reason.contains("a direct descriptor on 1"),
"{path:?}"
);
} else {
assert!(!path.reason.contains("registration"), "{path:?}");
}
let mut buf = sub.take_buf(4096).unwrap();
buf.as_mut_slice().fill(0x6B);
sub.write(&pages, pages.pos(8192).unwrap(), buf, WriteMode::Plain, 1)
.map_err(|r| r.error)
.unwrap();
for c in sub.wait(1).unwrap() {
assert!(matches!(c.outcome, Ok(Done::Written(_))));
}
let buf = sub.take_buf(4096).unwrap();
sub.read_page(&pages, pages.pos(8192).unwrap(), buf, 2)
.map_err(|r| r.error)
.unwrap();
let c = sub.wait(1).unwrap().next().unwrap();
assert!(matches!(c.outcome, Ok(Done::Read { len: 4096 })));
assert!(c.buf.unwrap().as_slice().iter().all(|&b| b == 0x6B));
let mut out = vec![0u8; 4096];
pages.read(pages.pos(8192).unwrap(), &mut out).unwrap();
assert!(
out.iter().all(|&b| b == 0x6B),
"the blocking read disagrees ({on})"
);
}
}
#[test]
fn test_flushes_in_flight_on_the_real_file_system() {
let t = TempDir::new("flushes");
let (mut opts, _) = options_for(t.path());
opts.flushes_in_flight = 4;
let store = Store::create(t.path().join("f"), opts.clone()).unwrap();
let ran = store.report().flushes_in_flight;
if cfg!(windows) {
assert_eq!(ran, 1);
} else {
assert!(ran == 1 || ran == 4, "{ran}");
}
let wal = store.provision_append_region("wal", 8 << 20).unwrap();
let acked = std::sync::Mutex::new(Vec::new());
std::thread::scope(|scope| {
for w in 0..8u8 {
let (wal, acked) = (&wal, &acked);
scope.spawn(move || {
for i in 0..50u8 {
let data = vec![w.wrapping_mul(31).wrapping_add(i); 700];
let (pos, receipt) = wal.append_durable(&data).unwrap();
assert!(receipt.durable_through() >= pos.offset() + data.len() as u64);
acked.lock().unwrap().push((pos.offset(), data));
}
});
}
});
let per_handle = std::fs::read_to_string("/proc/sys/kernel/osrelease").is_ok_and(|r| {
let mut v = r
.trim()
.split(|c: char| !c.is_ascii_digit())
.map(|x| x.parse::<u32>().unwrap_or(0));
(v.next().unwrap_or(0), v.next().unwrap_or(0)) >= (4, 16)
});
if store.domain_stats().flushes > 0 && per_handle {
assert_eq!(
ran, 4,
"flushes were needed and the kernel keeps errors per handle"
);
}
drop((wal, store));
let store = Store::open_with(t.path().join("f"), opts).unwrap();
let wal = store.append_region("wal").unwrap();
for (at, data) in acked.into_inner().unwrap() {
let mut out = vec![0u8; data.len()];
assert_eq!(wal.read(at, &mut out).unwrap(), data.len());
assert!(out == data, "append at {at}");
}
}
#[test]
fn test_concurrent_probes_of_one_directory() {
let t = TempDir::new("probes");
std::thread::scope(|scope| {
for _ in 0..4 {
let dir = t.path();
scope.spawn(move || {
for _ in 0..8 {
store_io::probe(dir).unwrap();
}
});
}
});
}
#[test]
fn test_a_directory_replace_takes_the_lock_on_the_real_file_system() {
use store_io_platform::{FileMode, FileName, Platform};
let t = TempDir::new("dirlock");
let (opts, _) = options_for(t.path());
let d = Directory::open_with(t.path(), true, opts.trust).unwrap();
d.replace("m", b"old").unwrap();
let p = store_io::NativePlatform::new();
let dir = p.open_dir(t.path(), false).unwrap();
let lock_file = p
.open_file(
&dir,
&FileName::new(".sio-lock").unwrap(),
FileMode::ReadWrite,
)
.unwrap();
let held = p.lock_exclusive(&lock_file).unwrap();
let r = d.replace("m", b"new");
assert!(matches!(r, Err(Error::Locked)), "{r:?}");
assert_eq!(d.read("m").unwrap(), b"old");
drop(held);
d.replace("m", b"new").unwrap();
assert_eq!(d.read("m").unwrap(), b"new");
}
#[test]
fn test_a_directory_s_largest_object_is_set_through_the_facade() {
let t = TempDir::new("dirmax");
let (opts, _) = options_for(t.path());
assert_eq!(Directory::DEFAULT_MAX_OBJECT, 16 << 20);
let d = Directory::open_with(t.path(), true, opts.trust)
.unwrap()
.with_max_object(4096);
assert_eq!(d.max_object(), 4096);
d.replace("m", &[1u8; 4096]).unwrap();
let r = d.replace("m", &[2u8; 4097]);
assert!(
matches!(
r,
Err(Error::NotWritten {
cause: store_io_core::error::NotWrittenCause::TooLarge,
..
})
),
"{r:?}"
);
assert_eq!(d.read("m").unwrap(), vec![1u8; 4096]);
}