use std::path::Path;
use std::sync::{Mutex, OnceLock, PoisonError};
use store_io_buf::{BufPool, PoolConfig};
use store_io_core::align::align_up;
use store_io_core::class::DurabilityClass;
use store_io_core::decide::{ClassDecision, Trust, decide};
use store_io_core::error::{
CorruptionKind, Error, ErrorContext, FirstCause, Named, NotWrittenCause, Op, OsError,
};
use store_io_platform::{FileMode, FileName, IoOp, Platform, QueueConfig};
use crate::exec::{QueueSet, Ran, run};
use crate::io::not_written;
const BLOCK: u64 = 4096;
const CHUNK: usize = 1 << 20;
const TEMP_SUFFIX: &str = ".sio-tmp";
const LOCK_NAME: &str = ".sio-lock";
const NAME_MAX: usize = 255 - TEMP_SUFFIX.len();
fn io(op: Op, raw: OsError) -> Error {
Error::Io {
op,
raw,
ctx: ErrorContext::default(),
}
}
fn name_of(name: &str) -> Result<FileName, Error> {
FileName::new(name)
.map_err(|_| not_written(NotWrittenCause::InvalidName, ErrorContext::default()))
}
fn object_name(name: &str) -> Result<FileName, Error> {
let folded: String = name
.chars()
.filter(|&c| !ignorable(c))
.map(|c| match c {
'\u{17F}' => 's',
'\u{212A}' => 'k',
c => c.to_ascii_lowercase(),
})
.collect();
let trimmed = folded.is_empty() || folded.ends_with(['.', ' ']);
let own = folded.ends_with(TEMP_SUFFIX) || folded == LOCK_NAME;
let too_long = name.len() > NAME_MAX;
let alias = short_name_shaped(name) || device_name(name);
if too_long || alias || trimmed || own {
return Err(not_written(
NotWrittenCause::InvalidName,
ErrorContext::default(),
));
}
name_of(name)
}
fn short_name_shaped(name: &str) -> bool {
let (base, ext) = name.split_once('.').unwrap_or((name, ""));
let Some((_, digits)) = base.rsplit_once('~') else {
return false;
};
!digits.is_empty()
&& digits.bytes().all(|b| b.is_ascii_digit())
&& base.chars().count() <= 8
&& ext.chars().count() <= 3
&& !ext.contains('.')
}
fn ignorable(c: char) -> bool {
matches!(
c,
'\u{AD}'
| '\u{34F}'
| '\u{61C}'
| '\u{115F}'..='\u{1160}'
| '\u{17B4}'..='\u{17B5}'
| '\u{180B}'..='\u{180F}'
| '\u{200B}'..='\u{200F}'
| '\u{202A}'..='\u{202E}'
| '\u{2060}'..='\u{206F}'
| '\u{3164}'
| '\u{FE00}'..='\u{FE0F}'
| '\u{FEFF}'
| '\u{FFA0}'
| '\u{FFF0}'..='\u{FFF8}'
| '\u{1BCA0}'..='\u{1BCA3}'
| '\u{1D173}'..='\u{1D17A}'
| '\u{E0000}'..='\u{E0FFF}'
)
}
fn device_name(name: &str) -> bool {
let stem = name.split('.').next().unwrap_or(name).trim_end();
let upper = stem.to_ascii_uppercase();
let numbered = |prefix: &str| {
upper.strip_prefix(prefix).is_some_and(|n| {
matches!(
n,
"0" | "1"
| "2"
| "3"
| "4"
| "5"
| "6"
| "7"
| "8"
| "9"
| "\u{B9}"
| "\u{B2}"
| "\u{B3}"
)
})
};
matches!(
upper.as_str(),
"CON" | "PRN" | "AUX" | "NUL" | "CONIN$" | "CONOUT$"
) || numbered("COM")
|| numbered("LPT")
}
pub struct Directory<P: Platform> {
platform: P,
dir: P::Dir,
trust: Trust,
decision: OnceLock<ClassDecision>,
poisoned: OnceLock<FirstCause>,
pool: BufPool,
queue: QueueSet<P::Queue>,
change: Mutex<()>,
lock_file: OnceLock<P::File>,
dir_flush: Option<OsError>,
max_object: u64,
}
impl<P: Platform> core::fmt::Debug for Directory<P> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("Directory")
.field("class", &self.class())
.field("poisoned", &self.poisoned.get().is_some())
.finish()
}
}
impl<P: Platform> Directory<P> {
pub const DEFAULT_MAX_OBJECT: u64 = 16 << 20;
pub fn open(platform: P, path: &Path, create: bool, trust: Trust) -> Result<Self, Error> {
let dir = platform.open_dir(path, create).map_err(|raw| {
if store_io_core::errno::is_not_found(raw) {
Error::NotFound { what: Named::Store }
} else {
io(Op::Open, raw)
}
})?;
let queue = platform
.queue(QueueConfig {
depth: 8,
..QueueConfig::default()
})
.map_err(|raw| io(Op::Queue, raw))?;
let pool = BufPool::new(&PoolConfig::uniform(4096, 4096, CHUNK, 4))
.map_err(|_| not_written(NotWrittenCause::PoolExhausted, ErrorContext::default()))?;
let dir_flush = platform.sync_dir(&dir).err();
Ok(Self {
platform,
dir,
trust,
decision: OnceLock::new(),
poisoned: OnceLock::new(),
pool,
queue: QueueSet::new(vec![queue], 8),
change: Mutex::new(()),
lock_file: OnceLock::new(),
dir_flush,
max_object: Self::DEFAULT_MAX_OBJECT,
})
}
#[must_use]
pub fn with_max_object(mut self, max: u64) -> Self {
self.max_object = max;
self
}
#[must_use]
pub fn max_object(&self) -> u64 {
self.max_object
}
#[must_use]
pub fn class(&self) -> Option<DurabilityClass> {
self.decision.get().map(|d| d.class)
}
#[must_use]
pub fn decision(&self) -> Option<&ClassDecision> {
self.decision.get()
}
fn admit(&self, file: &P::File) -> Result<(), Error> {
if self.decision.get().is_none() {
let ev = self
.platform
.probe(&self.dir, file)
.map_err(|raw| io(Op::Probe, raw))?;
let _first = self.decision.set(decide(&ev, &self.trust));
}
match self.decision.get() {
Some(d) => crate::store::refuse(d),
None => Err(not_written(
NotWrittenCause::NotReady,
ErrorContext::default(),
)),
}
}
fn poison(&self, op: Op, raw: Option<OsError>) -> Error {
let _first_kept = self.poisoned.set(FirstCause { op: Some(op), raw });
Error::DurabilityUnknown {
op,
raw,
ctx: ErrorContext::default(),
}
}
fn writable(&self) -> Result<(), Error> {
if let Some(first) = self.poisoned.get() {
return Err(Error::Poisoned { first: *first });
}
match self.dir_flush {
None => Ok(()),
Some(raw) if store_io_core::errno::is_unsupported(raw) => Err(Error::Unsupported {
what: store_io_core::error::Capability::DirectoryFlush,
}),
Some(raw) => Err(io(Op::SyncDir, raw)),
}
}
pub fn replace(&self, name: &str, data: &[u8]) -> Result<(), Error> {
self.writable()?;
if data.len() as u64 > self.max_object {
return Err(not_written(
NotWrittenCause::TooLarge,
ErrorContext::default(),
));
}
let target = object_name(name)?;
let temp = name_of(&format!("{name}{TEMP_SUFFIX}"))?;
let _one_at_a_time = self.change.lock().unwrap_or_else(PoisonError::into_inner);
self.writable()?;
let _owner = self.change_lock()?;
let _absent_or_removed = self.platform.unlink(&self.dir, &temp);
let file = self
.platform
.create_file(&self.dir, &temp)
.map_err(|raw| io(Op::Create, raw))?;
if let Err(e) = self.admit(&file).and_then(|()| self.fill(&file, data)) {
drop(file);
let _cleanup = self.platform.unlink(&self.dir, &temp);
return Err(e);
}
if let Some(first) = self.poisoned.get() {
drop(file);
let _cleanup = self.platform.unlink(&self.dir, &temp);
return Err(Error::Poisoned { first: *first });
}
let renamed = self
.platform
.rename_replace(&self.dir, &temp, &target, &file);
drop(file);
renamed.map_err(|raw| self.poison(Op::Rename, Some(raw)))?;
self.platform
.sync_dir(&self.dir)
.map_err(|raw| self.poison(Op::SyncDir, Some(raw)))
}
fn change_lock(&self) -> Result<P::Lock, Error> {
let file = match self.lock_file.get() {
Some(f) => f,
None => {
let name = name_of(LOCK_NAME)?;
let open = || {
self.platform
.open_file(&self.dir, &name, FileMode::ReadWrite)
};
let f = match open() {
Ok(f) => f,
Err(raw) if store_io_core::errno::is_not_found(raw) => {
match self.platform.create_file(&self.dir, &name) {
Ok(f) => f,
Err(raw) if store_io_core::errno::is_already_exists(raw) => {
open().map_err(|raw| io(Op::Open, raw))?
}
Err(raw) => return Err(io(Op::Create, raw)),
}
}
Err(raw) => return Err(io(Op::Open, raw)),
};
let _first = self.lock_file.set(f);
self.lock_file.get().ok_or_else(|| {
not_written(NotWrittenCause::NotReady, ErrorContext::default())
})?
}
};
self.platform.lock_exclusive(file).map_err(|raw| {
if store_io_core::errno::is_lock_held(raw) {
Error::Locked
} else {
io(Op::Lock, raw)
}
})
}
fn fill(&self, file: &P::File, data: &[u8]) -> Result<(), Error> {
let c = ErrorContext::default();
let len = data.len() as u64;
let padded =
align_up(len, BLOCK).ok_or_else(|| not_written(NotWrittenCause::TooLarge, c))?;
self.platform
.allocate(file, padded)
.map_err(|raw| crate::store::space_err(Op::Allocate, raw, 0))?;
let mut lane = self.queue.get(0);
for (i, piece) in data.chunks(CHUNK).enumerate() {
let piece_len = align_up(piece.len() as u64, BLOCK).unwrap_or(BLOCK) as usize;
let mut buf = self
.pool
.take(piece_len)
.map_err(|_| not_written(NotWrittenCause::PoolExhausted, c))?;
let dst = buf.as_mut_slice();
dst[..piece.len()].copy_from_slice(piece);
dst[piece.len()..].fill(0);
let ran = run(
&mut lane,
IoOp::Write {
file,
offset: (i * CHUNK) as u64,
buf,
dsync: false,
},
)
.map_err(|(_b, raw)| {
raw.map_or_else(
|| not_written(NotWrittenCause::QueueFull, c),
|r| io(Op::Write, r),
)
})?;
let result = match ran {
Ran::Done { result, .. } => result,
Ran::Abandoned(raw) => Err(raw),
};
match result {
Ok(n) if n == piece_len => {}
Ok(_) => return Err(self.poison(Op::Write, None)),
Err(raw) => return Err(self.poison(Op::Write, Some(raw))),
}
}
drop(lane);
self.platform
.set_len(file, len)
.map_err(|raw| self.poison(Op::Allocate, Some(raw)))?;
self.platform
.flush_all(file)
.map_err(|raw| self.poison(Op::FlushAll, Some(raw)))
}
pub fn read(&self, name: &str) -> Result<Vec<u8>, Error> {
let c = ErrorContext::default();
let file = self
.platform
.open_file(&self.dir, &object_name(name)?, FileMode::ReadOnly)
.map_err(|raw| {
if store_io_core::errno::is_not_found(raw) {
Error::NotFound { what: Named::Slot }
} else {
io(Op::Open, raw)
}
})?;
let len = self.platform.size(&file).map_err(|raw| io(Op::Open, raw))?;
if len > self.max_object {
return Err(not_written(NotWrittenCause::TooLarge, c));
}
let len = usize::try_from(len).map_err(|_| not_written(NotWrittenCause::TooLarge, c))?;
let mut out = vec![0u8; len];
let mut lane = self.queue.get(0);
let mut at = 0usize;
while at < len {
let want = (len - at).min(CHUNK);
let padded = align_up(want as u64, BLOCK).unwrap_or(BLOCK) as usize;
let buf = self
.pool
.take(padded)
.map_err(|_| not_written(NotWrittenCause::PoolExhausted, c))?;
let ran = run(
&mut lane,
IoOp::Read {
file: &file,
offset: at as u64,
buf,
},
)
.map_err(|(_b, raw)| {
raw.map_or_else(
|| not_written(NotWrittenCause::QueueFull, c),
|r| io(Op::Read, r),
)
})?;
let (got, result) = match ran {
Ran::Done { buf, result } => (buf, result),
Ran::Abandoned(raw) => return Err(io(Op::Read, raw)),
};
let n = result.map_err(|raw| {
if store_io_core::errno::is_media_error(raw) {
Error::Corruption {
kind: CorruptionKind::MediaError,
ctx: c,
}
} else {
io(Op::Read, raw)
}
})?;
let Some(buf) = got else {
return Err(not_written(NotWrittenCause::QueueFull, c));
};
let got = n.min(want);
out[at..at + got].copy_from_slice(&buf.as_slice()[..got]);
if got < want {
out.truncate(at + got);
break;
}
at += got;
}
Ok(out)
}
pub fn remove(&self, name: &str) -> Result<(), Error> {
self.writable()?;
let target = object_name(name)?;
let _one_at_a_time = self.change.lock().unwrap_or_else(PoisonError::into_inner);
self.writable()?;
match self.platform.unlink(&self.dir, &target) {
Ok(()) => {}
Err(raw) if store_io_core::errno::is_not_found(raw) => {
return Err(Error::NotFound { what: Named::Slot });
}
Err(raw) => return Err(self.poison(Op::Unlink, Some(raw))),
}
self.platform
.sync_dir(&self.dir)
.map_err(|raw| self.poison(Op::SyncDir, Some(raw)))
}
pub fn sync(&self) -> Result<(), Error> {
self.writable()?;
self.platform
.sync_dir(&self.dir)
.map_err(|raw| self.poison(Op::SyncDir, Some(raw)))
}
}