use std::cell::RefCell;
use std::collections::VecDeque;
use std::marker::PhantomData;
use std::path::Path;
use std::rc::{Rc, Weak};
use std::sync::Arc;
use store_io_buf::{BufPool, IoBuf, PoolConfig};
use store_io_core::error::{Error, ErrorContext, Named, NotWrittenCause, Op, OsError, ReserveTag};
use store_io_format::crc32c::crc32c_append;
use store_io_format::exportinfo::{self, InfoHeader, RegionRecord, SPAN};
use store_io_format::meta::{RegionKind, RegionName};
use store_io_format::meta2::max_object;
use store_io_platform::{FileName, IoOp, Owner, Platform, Queue, QueueConfig, RawResult};
use crate::call::{self, CallState};
use crate::exec::{Lane, LaneMark, owned_lane};
use crate::export::{ExportHeader, ExportSink, RegionInfo, SinkError};
use crate::io::not_written;
use crate::pace::{Held, Pace, Registered};
use crate::qos::Collect;
use crate::store::StoreOptions;
pub const REGIONS_INFO: &str = "regions.info";
const UNPACED_PIECE: usize = 256 << 10;
pub(crate) const DEPTH: usize = 8;
struct Pending {
tag: u64,
offset: u64,
len: usize,
result: Option<RawResult<usize>>,
charge: Option<Held>,
}
struct Writes<Q: Queue> {
lane: Lane<Q>,
pending: VecDeque<Pending>,
free: Vec<IoBuf>,
done_to: u64,
failed: Option<(Error, u64)>,
wait_failed: Option<(OsError, u64)>,
next_tag: u64,
}
impl<Q: Queue> Writes<Q> {
fn submit(
&mut self,
file: &Q::File,
offset: u64,
buf: IoBuf,
charge: Option<Held>,
) -> Result<(), Error> {
let len = buf.len();
let tag = self.next_tag;
let op = IoOp::Write {
file,
offset,
buf,
dsync: false,
};
match self.lane.submit(op, tag) {
Ok(()) => {
self.next_tag += 1;
self.pending.push_back(Pending {
tag,
offset,
len,
result: None,
charge,
});
Ok(())
}
Err(rejected) => {
if let Some(b) = rejected.buf {
self.free.push(b);
}
Err(rejected.raw.map_or_else(
|| not_written(NotWrittenCause::QueueFull, ErrorContext::default()),
|r| io(Op::Write, r),
))
}
}
}
fn file(&mut self) {
for comp in self.lane.done.drain() {
if let Some(w) = self.pending.iter_mut().find(|w| w.tag == comp.tag) {
w.result = Some(comp.result);
w.charge = None;
}
if let Some(b) = comp.buf {
self.free.push(b);
}
}
while let Some(w) = self.pending.front() {
let Some(result) = w.result else {
break;
};
if self.failed.is_none() {
match result {
Ok(n) if n == w.len => self.done_to = w.offset + w.len as u64,
Ok(_) => {
self.failed = Some((
not_written(NotWrittenCause::Interrupted, ErrorContext::default()),
w.offset,
));
}
Err(raw) => self.failed = Some((io(Op::Write, raw), w.offset)),
}
}
let _done = self.pending.pop_front();
}
}
fn reap(&mut self) {
let _arrived = self.lane.reap();
self.file();
}
fn wait_one(&mut self) -> Result<bool, OsError> {
if let Some((raw, _)) = self.wait_failed {
return Err(raw);
}
if self.pending.is_empty() {
return Ok(false);
}
match self.lane.wait(1) {
Ok(_) => {
self.file();
Ok(true)
}
Err(raw) => {
self.file();
let lost = self.pending.front().map_or(self.done_to, |w| w.offset);
self.wait_failed = Some((raw, lost));
if self.failed.is_none() {
self.failed = Some((io(Op::Write, raw), lost));
}
for w in &mut self.pending {
w.charge = None;
}
Err(raw)
}
}
}
fn wait_all(&mut self) -> Result<(), OsError> {
while self.wait_one()? {}
Ok(())
}
}
impl<Q: Queue> Collect for RefCell<Writes<Q>> {
fn collect_one(&self) -> Result<bool, OsError> {
match self.try_borrow_mut() {
Ok(mut w) => w.wait_one(),
Err(_) => Ok(false),
}
}
fn collect_all(&self) -> Result<(), OsError> {
match self.try_borrow_mut() {
Ok(mut w) => w.wait_all(),
Err(_) => Ok(()),
}
}
fn failed(&self) -> Option<(OsError, u64)> {
self.try_borrow().ok()?.wait_failed
}
}
#[derive(Debug, Clone, Default)]
#[non_exhaustive]
pub struct FileSinkOptions {
pub store: StoreOptions,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum State {
Fresh,
Begun,
InRegion { declared: u64, written: u64 },
Ended,
Finished,
Failed,
}
fn data_name(index: u32) -> String {
format!("region-{index:05}.data")
}
fn file_name(name: &str) -> Result<FileName, Error> {
FileName::new(name).map_err(|_| refusal())
}
fn refusal() -> Error {
not_written(NotWrittenCause::InvalidOptions, ErrorContext::default())
}
fn io(op: Op, raw: OsError) -> Error {
Error::Io {
op,
raw,
ctx: ErrorContext::default(),
}
}
fn shown(e: &Error) -> SinkError {
match e {
Error::Io { raw, .. } => SinkError::Io(*raw),
_ => SinkError::Refused,
}
}
pub struct FileSink<P: Platform> {
platform: P,
dir: P::Dir,
opts: FileSinkOptions,
state: State,
header: Option<ExportHeader>,
call: Option<Rc<CallState>>,
id: usize,
pace: Option<Pace>,
writes: Option<Rc<RefCell<Writes<P::Queue>>>>,
registered: Option<Registered>,
pool: Option<BufPool>,
block: u64,
piece: usize,
stage: Option<IoBuf>,
fill: usize,
at: u64,
info: Option<P::File>,
file: Option<P::File>,
cur: Option<RegionRecord>,
index: u32,
span_crc: u32,
span_len: u64,
spans: Vec<u32>,
done: Vec<(RegionRecord, Vec<u32>)>,
charged: u64,
admit_failed: bool,
_thread: PhantomData<*const ()>,
}
impl<P: Platform> core::fmt::Debug for FileSink<P> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("FileSink")
.field("state", &self.state)
.field("regions", &self.done.len())
.finish_non_exhaustive()
}
}
impl<P: Platform> FileSink<P> {
pub fn create(platform: P, dir: &Path, opts: FileSinkOptions) -> Result<Self, Error> {
let d = platform.open_dir(dir, false).map_err(|raw| {
if store_io_core::errno::is_not_found(raw) {
Error::NotFound { what: Named::Store }
} else {
io(Op::Open, raw)
}
})?;
if !platform.dir_is_empty(&d).map_err(|raw| io(Op::Open, raw))? {
return Err(refusal());
}
Ok(Self {
platform,
dir: d,
opts,
state: State::Fresh,
header: None,
call: None,
id: 0,
pace: None,
writes: None,
registered: None,
pool: None,
block: 0,
piece: 0,
stage: None,
fill: 0,
at: 0,
info: None,
file: None,
cur: None,
index: 0,
span_crc: 0,
span_len: 0,
spans: Vec::new(),
done: Vec::new(),
charged: 0,
admit_failed: false,
_thread: PhantomData,
})
}
fn fail(&mut self, e: Error, offset: u64) -> SinkError {
self.state = State::Failed;
if let Some(w) = &self.writes {
if let Ok(mut ws) = w.try_borrow_mut() {
let _waited = ws.wait_all();
}
}
let shown = shown(&e);
if let Some(c) = &self.call {
if !self.admit_failed {
c.part_failed(e, offset);
}
}
shown
}
fn refuse(&mut self, offset: u64) -> SinkError {
self.fail(refusal(), offset)
}
fn admits(&self, info: &RegionInfo, header: &ExportHeader) -> Option<u64> {
if self.index >= header.region_count || info.validate(header.block_size).is_err() {
return None;
}
if self.done.iter().any(|(r, _)| r.name.as_str() == info.name) {
return None;
}
let block = header.block_size;
let data = match info.kind {
RegionKind::Slot => max_object(block.trailing_zeros() as u8) as u64,
_ => info.cap.unwrap_or(0).max(info.data_size),
};
let charged = self
.charged
.checked_add(2 * block)
.and_then(|c| c.checked_add(data))?;
(charged <= header.total).then_some(charged)
}
fn write_stage(&mut self, len: usize, info_file: bool) -> Result<(), Error> {
let Some(w) = self.writes.clone() else {
return Err(refusal());
};
self.failure_of(&w)?;
let charge = match &self.pace {
Some(p) => match p.admit() {
Ok(h) => Some(h),
Err(e) => {
self.failure_of(&w)?;
self.admit_failed = true;
return Err(e);
}
},
None => None,
};
self.failure_of(&w)?;
let Some(mut buf) = self.stage.take() else {
return Err(refusal());
};
if !buf.set_len(len) {
self.stage = Some(buf);
return Err(refusal());
}
let file = if info_file { &self.info } else { &self.file };
let Some(file) = file.as_ref() else {
self.stage = Some(buf);
return Err(refusal());
};
w.borrow_mut().submit(file, self.at, buf, charge)?;
self.at += len as u64;
self.stage = loop {
let mut ws = w.borrow_mut();
ws.reap();
if let Some(b) = ws.free.pop() {
break Some(b);
}
if !ws.wait_one().map_err(|raw| io(Op::Write, raw))? {
break None;
}
};
self.failure_of(&w)
}
fn failure_of(&self, w: &Rc<RefCell<Writes<P::Queue>>>) -> Result<(), Error> {
match &w.borrow().failed {
Some((e, _)) => Err(e.clone()),
None => Ok(()),
}
}
fn settle_writes(&self) -> Result<(), Error> {
let Some(w) = &self.writes else {
return Err(refusal());
};
let waited = w.borrow_mut().wait_all();
self.failure_of(w)?;
waited.map_err(|raw| io(Op::Write, raw))
}
fn written(&self) -> u64 {
self.writes.as_ref().map_or(0, |w| {
let mut ws = w.borrow_mut();
ws.reap();
ws.done_to
})
}
fn writes_failed(&self) -> bool {
self.writes
.as_ref()
.is_some_and(|w| w.borrow().failed.is_some())
}
fn failed_at(&self) -> u64 {
self.writes.as_ref().map_or(0, |w| {
let mut ws = w.borrow_mut();
let _waited = ws.wait_all();
ws.done_to
})
}
fn start_file(&mut self) {
if let Some(w) = &self.writes {
w.borrow_mut().done_to = 0;
}
self.fill = 0;
self.at = 0;
}
fn drain_stage(&mut self, info_file: bool) -> Result<(), Error> {
if self.fill == 0 {
return Ok(());
}
let block = self.block as usize;
let len = self.fill.div_ceil(block) * block;
if let Some(b) = self.stage.as_mut() {
b.as_mut_capacity()[self.fill..len].fill(0);
}
self.write_stage(len, info_file)?;
self.fill = 0;
Ok(())
}
fn stage_bytes(&mut self, mut bytes: &[u8], info_file: bool) -> Result<(), Error> {
while !bytes.is_empty() {
let Some(b) = self.stage.as_mut() else {
return Err(not_written(
NotWrittenCause::PoolExhausted,
ErrorContext::default(),
));
};
let n = bytes.len().min(self.piece - self.fill);
b.as_mut_capacity()[self.fill..self.fill + n].copy_from_slice(&bytes[..n]);
self.fill += n;
bytes = &bytes[n..];
if self.fill == self.piece {
self.write_stage(self.piece, info_file)?;
self.fill = 0;
}
}
Ok(())
}
fn crc_bytes(&mut self, mut bytes: &[u8]) {
while !bytes.is_empty() {
let n = bytes.len().min((SPAN - self.span_len) as usize);
self.span_crc = crc32c_append(self.span_crc, &bytes[..n]);
self.span_len += n as u64;
bytes = &bytes[n..];
if self.span_len == SPAN {
self.spans.push(self.span_crc);
self.span_crc = 0;
self.span_len = 0;
}
}
}
fn settle_file(&self, file: &P::File, len: u64) -> Result<(), Error> {
self.platform
.set_len(file, len)
.map_err(|raw| io(Op::Allocate, raw))?;
self.platform
.flush_all(file)
.map_err(|raw| io(Op::FlushAll, raw))
}
fn sync_dir(&self) -> Result<(), Error> {
self.platform
.sync_dir(&self.dir)
.map_err(|raw| io(Op::SyncDir, raw))
}
fn begin_run(&mut self, header: &ExportHeader) -> Result<(), Error> {
self.call = call::current();
if let Some(c) = &self.call {
self.id = c.sink_bound();
}
let block = header.block_size;
if !block.is_power_of_two() || !(512..=1 << 16).contains(&block) {
return Err(refusal());
}
if header.region_count > crate::v2::MAX_REGION_CAPACITY {
return Err(refusal());
}
let name = file_name(REGIONS_INFO)?;
let info = self
.platform
.create_file(&self.dir, &name)
.map_err(|raw| io(Op::Create, raw))?;
let free = self
.platform
.free_space(&self.dir)
.map_err(|raw| io(Op::Open, raw))?;
if free < header.total {
return Err(Error::NoSpace {
tag: ReserveTag::Caller(0),
ctx: ErrorContext::default(),
});
}
let ev = self
.platform
.probe(&self.dir, &info)
.map_err(|raw| io(Op::Probe, raw))?;
let fs_block = 1u64 << crate::layout::choose_log2_block(&ev, None);
self.block = fs_block.max(block);
let qos = crate::store::join_group(&self.platform, &ev, &self.opts.store, self.block);
let clock = self.platform.clock();
self.pace = match &self.call {
Some(c) => c.pace_for(&qos, &clock),
None => Some(Pace::new(&qos, clock)),
};
let piece = self.pace.as_ref().map_or(UNPACED_PIECE, Pace::piece);
self.piece = (piece as u64).max(self.block).next_power_of_two() as usize;
let align = [
4096,
ev.fs.dio_mem_align as usize,
ev.device.logical_block as usize,
]
.into_iter()
.max()
.unwrap_or(4096)
.next_power_of_two();
let pool = BufPool::new(&PoolConfig::uniform(
align.min(self.piece),
self.piece,
self.piece,
DEPTH as u32,
))
.map_err(|_| not_written(NotWrittenCause::PoolExhausted, ErrorContext::default()))?;
let mut free = Vec::with_capacity(DEPTH);
for _ in 0..DEPTH {
free.push(pool.take(self.piece).map_err(|_| {
not_written(NotWrittenCause::PoolExhausted, ErrorContext::default())
})?);
}
self.stage = free.pop();
self.pool = Some(pool);
let queue = self
.platform
.queue(QueueConfig {
depth: DEPTH as u32,
parallel: true,
pool_threads: self.opts.store.t3_pool_threads,
owner: Owner::Thread,
})
.map_err(|raw| io(Op::Queue, raw))?;
let writes = Rc::new(RefCell::new(Writes {
lane: owned_lane(queue, &Arc::new(LaneMark::new()), DEPTH),
pending: VecDeque::with_capacity(DEPTH),
free,
done_to: 0,
failed: None,
wait_failed: None,
next_tag: 0,
}));
if let Some(p) = &self.pace {
let part: Rc<dyn Collect> = writes.clone();
let weak: Weak<dyn Collect> = Rc::downgrade(&part);
self.registered = Some(p.register(weak));
}
self.writes = Some(writes);
self.info = Some(info);
self.header = Some(header.clone());
Ok(())
}
fn region_run(&mut self, info: &RegionInfo) -> Result<(), Error> {
let Some(header) = self.header.as_ref() else {
return Err(refusal());
};
let Some(charged) = self.admits(info, header) else {
return Err(refusal());
};
let Some(record) = info.to_record() else {
return Err(refusal());
};
let name = file_name(&data_name(self.index))?;
let file = self
.platform
.create_file(&self.dir, &name)
.map_err(|raw| io(Op::Create, raw))?;
let len = info.stream_len().div_ceil(self.block) * self.block;
if len > 0 {
self.platform
.allocate(&file, len)
.map_err(|raw| io(Op::Allocate, raw))?;
}
self.charged = charged;
self.file = Some(file);
self.cur = Some(record);
self.start_file();
self.span_crc = 0;
self.span_len = 0;
self.spans = Vec::new();
Ok(())
}
fn end_run(&mut self, declared: u64) -> Result<(), Error> {
self.drain_stage(false)?;
self.settle_writes()?;
if self.span_len > 0 {
self.spans.push(self.span_crc);
self.span_len = 0;
}
let (Some(file), Some(record)) = (self.file.take(), self.cur.take()) else {
return Err(refusal());
};
self.settle_file(&file, declared)?;
self.sync_dir()?;
self.done.push((record, core::mem::take(&mut self.spans)));
self.index += 1;
Ok(())
}
fn finish_run(&mut self) -> Result<(), Error> {
let Some(header) = self.header.clone() else {
return Err(refusal());
};
if self.index != header.region_count || self.charged > header.total {
return Err(refusal());
}
let facts = &header.facts;
let omitted: Vec<u64> = facts.omitted.iter().map(|id| id.get()).collect();
let mut verified = Vec::with_capacity(facts.verified_up_to.len());
for (name, len) in &facts.verified_up_to {
verified.push((RegionName::new(name).map_err(|_| refusal())?, *len));
}
verified.sort_by_key(|(n, _)| n.as_padded());
let mut omitted_sorted = omitted;
omitted_sorted.sort_unstable();
let regions: Vec<exportinfo::RegionItem<'_>> =
self.done.iter().map(|(r, s)| (*r, s.as_slice())).collect();
let h = InfoHeader {
writable: header.writable,
block_log2: header.block_size.trailing_zeros() as u8,
region_count: header.region_count,
lend: u32::try_from(header.lend).unwrap_or(u32::MAX),
total: header.total,
omitted_count: 0,
lost_count: 0,
stale_count: 0,
verified_count: 0,
};
let len = exportinfo::encoded_len(
omitted_sorted.len(),
facts.lost_pages.len(),
facts.stale_pages.len(),
verified.len(),
®ions,
)
.ok_or_else(refusal)?;
let mut bytes = vec![0u8; len];
let n = exportinfo::encode(
&h,
&omitted_sorted,
&facts.lost_pages,
&facts.stale_pages,
&verified,
®ions,
&mut bytes,
)
.map_err(|_| refusal())?;
drop(regions);
self.start_file();
self.stage_bytes(&bytes[..n], true)?;
self.drain_stage(true)?;
self.settle_writes()?;
let Some(info) = self.info.take() else {
return Err(refusal());
};
self.settle_file(&info, n as u64)?;
self.sync_dir()
}
}
impl<P: Platform> Drop for FileSink<P> {
fn drop(&mut self) {
if let Some(w) = &self.writes {
if let Ok(mut ws) = w.try_borrow_mut() {
let _waited = ws.wait_all();
}
}
}
}
impl<P: Platform> ExportSink for FileSink<P> {
fn begin(&mut self, header: &ExportHeader) -> Result<(), SinkError> {
if self.state != State::Fresh {
return Err(self.refuse(0));
}
match self.begin_run(header) {
Ok(()) => {
self.state = State::Begun;
Ok(())
}
Err(e) => Err(self.fail(e, 0)),
}
}
fn region(&mut self, info: &RegionInfo) -> Result<(), SinkError> {
if !matches!(self.state, State::Begun | State::Ended) {
return Err(self.refuse(0));
}
match self.region_run(info) {
Ok(()) => {
self.state = State::InRegion {
declared: info.stream_len(),
written: 0,
};
Ok(())
}
Err(e) => Err(self.fail(e, 0)),
}
}
fn data(&mut self, chunk: crate::stream::Chunk) -> Result<(), SinkError> {
let State::InRegion { declared, written } = self.state else {
return Err(self.refuse(0));
};
let bytes = chunk.bytes();
let n = bytes.len() as u64;
if chunk.offset() != written || n > declared - written {
return Err(self.refuse(written));
}
self.crc_bytes(bytes);
let staged = self.stage_bytes(bytes, false);
match staged {
Ok(()) => {
if let Some(c) = &self.call {
c.wrote(self.id, self.written().min(declared));
}
self.state = State::InRegion {
declared,
written: written + n,
};
Ok(())
}
Err(e) => {
let at = self.failed_at();
if let Some(c) = &self.call {
c.wrote(self.id, at.min(declared));
}
Err(self.fail(e, at))
}
}
}
fn end_region(&mut self) -> Result<(), SinkError> {
let State::InRegion { declared, written } = self.state else {
return Err(self.refuse(0));
};
if written != declared {
return Err(self.refuse(written));
}
let before = self.written().min(declared);
match self.end_run(declared) {
Ok(()) => {
self.state = State::Ended;
if let Some(c) = &self.call {
c.region_ended(self.id);
}
Ok(())
}
Err(e) => {
let at = if self.writes_failed() {
self.failed_at().min(declared)
} else {
before
};
if let Some(c) = &self.call {
c.wrote(self.id, at);
}
Err(self.fail(e, at))
}
}
}
fn finish(&mut self) -> Result<(), SinkError> {
if !matches!(self.state, State::Begun | State::Ended) {
return Err(self.refuse(0));
}
match self.finish_run() {
Ok(()) => {
self.state = State::Finished;
if let Some(c) = &self.call {
c.sink_finished();
}
Ok(())
}
Err(e) => Err(self.fail(e, 0)),
}
}
}
#[cfg(all(test, not(loom)))]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, unused_results)]
use std::path::Path;
use std::sync::Arc;
use store_io_format::meta::FillPattern;
use store_io_sim::{SimConfig, SimPlatform};
use super::*;
use crate::Store;
use crate::export::VolumeFacts;
struct InFlight {
p: SimPlatform,
_s: Store<SimPlatform>,
call: Rc<CallState>,
pace: Pace,
sink: FileSink<SimPlatform>,
_bound: call::Bound,
}
fn begun_in_flight(seed: u64) -> InFlight {
let p = SimPlatform::new(SimConfig::volatile(seed));
let s = Store::create(p.clone(), Path::new("/db"), StoreOptions::default()).unwrap();
drop(p.open_dir(Path::new("/out"), true).unwrap());
let pace = s.inner.domain.new_pace();
let call = CallState::new(Arc::clone(&s.inner.qos), pace.clone());
let bound = call::bind(&call);
let mut sink =
FileSink::create(p.clone(), Path::new("/out"), FileSinkOptions::default()).unwrap();
let header = ExportHeader {
region_count: 1,
block_size: 4096,
facts: VolumeFacts::default(),
writable: true,
lend: 4,
total: 1 << 30,
};
sink.begin(&header).unwrap();
let info = RegionInfo {
name: "r".to_owned(),
kind: RegionKind::Page,
generation: 1,
tag: 0,
cap: None,
fill: FillPattern::Zeros,
fill_key: [0; 16],
block_size: 4096,
data_size: 1 << 20,
durable_len: None,
object_len: None,
full_copy: false,
superseded: false,
};
sink.region(&info).unwrap();
p.with_world(|w| w.hold_reaps(1 << 40));
InFlight {
p,
_s: s,
call,
pace: pace.unwrap(),
sink,
_bound: bound,
}
}
fn hold_the_rest(pace: &Pace) -> Vec<Held> {
let mut held = Vec::new();
while let Some(h) = pace.try_charge() {
held.push(h);
assert!(held.len() < 1024, "an admission that never refuses");
}
held
}
#[test]
fn test_a_failed_wait_inside_an_admission_is_the_sink_s_failure() {
let mut t = begun_in_flight(3120);
let piece = t.sink.piece;
t.sink.stage_bytes(&vec![7u8; 2 * piece], false).unwrap();
assert_eq!(t.sink.writes.as_ref().unwrap().borrow().pending.len(), 2);
let held = hold_the_rest(&t.pace);
t.p.with_world(|w| {
let n = w.waits();
w.faults_mut().fail_wait = Some((n + 1, 5));
});
let e = t.sink.stage_bytes(&vec![7u8; piece], false).unwrap_err();
drop(held);
assert!(matches!(e, Error::Io { op: Op::Write, .. }), "{e:?}");
assert!(!t.sink.admit_failed);
let at = t.sink.failed_at();
let _shown = t.sink.fail(e, at);
let f = t.call.failure().expect("recorded as the sink's");
assert!(matches!(f.error, Error::Io { op: Op::Write, .. }));
assert_eq!(f.offset, 0);
}
#[test]
fn test_a_write_failure_collected_by_an_admission_is_returned_first() {
let mut t = begun_in_flight(3122);
let piece = t.sink.piece;
t.p.with_world(|w| {
let n = w.writes();
w.faults_mut().fail_write = Some(n + 1);
});
t.sink.stage_bytes(&vec![7u8; 2 * piece], false).unwrap();
let held = hold_the_rest(&t.pace);
t.p.with_world(|w| {
let n = w.write_submits();
w.faults_mut().fail_submit = Some((n + 1, 28));
});
let e = t.sink.stage_bytes(&vec![7u8; piece], false).unwrap_err();
drop(held);
match e {
Error::Io {
op: Op::Write, raw, ..
} => assert_eq!(raw.code, 5, "{e:?}"),
_ => panic!("{e:?}"),
}
assert_eq!(t.sink.failed_at(), 0);
}
#[test]
fn test_a_failed_sink_holds_no_piece() {
let mut t = begun_in_flight(3124);
let piece = t.sink.piece;
t.sink.stage_bytes(&vec![7u8; 2 * piece], false).unwrap();
assert_eq!(t.pace.held_here(), 2);
let _shown = t.sink.refuse(0);
assert_eq!(t.pace.held_here(), 0);
assert!(t.sink.writes.as_ref().unwrap().borrow().pending.is_empty());
}
#[test]
fn test_a_dropped_sink_completes_its_writes_in_flight() {
let mut t = begun_in_flight(3126);
let piece = t.sink.piece;
t.sink.stage_bytes(&vec![7u8; 2 * piece], false).unwrap();
let before = t.p.with_world(|w| w.writes());
let InFlight { p, sink, .. } = t;
drop(sink);
assert_eq!(p.with_world(|w| w.writes()), before + 2);
}
#[test]
fn test_a_failed_write_stops_the_writes_done_at_its_start() {
let p = SimPlatform::new(SimConfig::volatile(3110));
let d = p.open_dir(Path::new("/w"), true).unwrap();
let f = p.create_file(&d, &FileName::new("f").unwrap()).unwrap();
let q = p
.queue(QueueConfig {
depth: DEPTH as u32,
..QueueConfig::default()
})
.unwrap();
let pool = BufPool::new(&PoolConfig::uniform(4096, 4096, 4096, 4)).unwrap();
let mut w = Writes {
lane: owned_lane(q, &Arc::new(LaneMark::new()), DEPTH),
pending: VecDeque::new(),
free: Vec::new(),
done_to: 0,
failed: None,
wait_failed: None,
next_tag: 0,
};
p.with_world(|w| {
let n = w.writes();
w.faults_mut().fail_write = Some(n + 2);
});
for i in 0..3u64 {
let mut b = pool.take(4096).unwrap();
assert!(b.set_len(4096));
w.submit(&f, i * 4096, b, None).unwrap();
}
w.wait_all().unwrap();
assert_eq!(w.done_to, 4096);
assert!(matches!(
w.failed,
Some((Error::Io { op: Op::Write, .. }, 4096))
));
assert!(w.pending.is_empty());
assert_eq!(w.free.len(), 3);
}
#[test]
fn test_an_admission_ended_by_another_part_is_not_the_sink_s_failure() {
let p = SimPlatform::new(SimConfig::volatile(3100));
let s = Store::create(p.clone(), Path::new("/db"), StoreOptions::default()).unwrap();
drop(p.open_dir(Path::new("/out"), true).unwrap());
let pace = s.inner.domain.new_pace();
let call = CallState::new(Arc::clone(&s.inner.qos), pace.clone());
let _bound = call::bind(&call);
let mut sink =
FileSink::create(p.clone(), Path::new("/out"), FileSinkOptions::default()).unwrap();
let header = ExportHeader {
region_count: 1,
block_size: 4096,
facts: VolumeFacts::default(),
writable: true,
lend: 4,
total: 1 << 30,
};
sink.begin(&header).unwrap();
let info = RegionInfo {
name: "r".to_owned(),
kind: RegionKind::Page,
generation: 1,
tag: 0,
cap: None,
fill: FillPattern::Zeros,
fill_key: [0; 16],
block_size: 4096,
data_size: 1 << 20,
durable_len: None,
object_len: None,
full_copy: false,
superseded: false,
};
sink.region(&info).unwrap();
let pace = pace.unwrap();
let mut held = Vec::new();
while let Some(h) = pace.try_charge() {
held.push(h);
assert!(held.len() < 1024, "an admission that never refuses");
}
let piece = sink.piece;
let e = sink.stage_bytes(&vec![7u8; piece], false).unwrap_err();
assert!(sink.admit_failed);
let at = sink.at;
let _shown = sink.fail(e, at);
assert_eq!(sink.state, State::Failed);
assert!(call.failure().is_none(), "recorded as the sink's");
sink.admit_failed = false;
let _shown = sink.fail(refusal(), 0);
assert!(call.failure().is_some());
}
}