use std::marker::PhantomData;
use std::path::{Path, PathBuf};
use std::rc::Rc;
use store_io_core::error::Error;
use store_io_format::meta::RegionKind;
use store_io_platform::Platform;
use crate::call::{self, CallState};
use crate::export::{ExportHeader, ExportSink, RegionInfo, SinkError};
use crate::provision2::Pushed;
use crate::restore::{Restore, check_header, invalid};
use crate::store::StoreOptions;
use crate::target::TargetDir;
#[derive(Debug, Clone, Default)]
#[non_exhaustive]
pub struct StoreSinkOptions {
pub store: StoreOptions,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum State {
Fresh,
Begun,
InRegion { declared: u64, written: u64 },
Ended,
Finished,
Failed,
}
enum Cur<P: Platform>
where
P::Queue: Send,
{
Area(Box<Pushed<P>>),
Slot(Vec<u8>),
}
fn shown(e: &Error) -> SinkError {
match e {
Error::Io { raw, .. } | Error::DurabilityUnknown { raw: Some(raw), .. } => {
SinkError::Io(*raw)
}
_ => SinkError::Refused,
}
}
pub struct StoreSink<P: Platform + Clone>
where
P::Queue: Send,
{
platform: P,
dir: PathBuf,
opts: StoreSinkOptions,
state: State,
call: Option<Rc<CallState>>,
id: usize,
mark: u64,
header: Option<ExportHeader>,
cur: Option<(RegionInfo, Cur<P>)>,
restore: Option<Restore<P>>,
target: Option<TargetDir<P>>,
done: Vec<RegionInfo>,
_thread: PhantomData<*const ()>,
}
impl<P: Platform + Clone> core::fmt::Debug for StoreSink<P>
where
P::Queue: Send,
{
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("StoreSink")
.field("state", &self.state)
.field("regions", &self.done.len())
.finish_non_exhaustive()
}
}
impl<P: Platform + Clone> StoreSink<P>
where
P::Queue: Send,
{
pub fn create(platform: P, dir: &Path, opts: StoreSinkOptions) -> Result<Self, Error> {
let target = TargetDir::open(&platform, dir)?;
Ok(Self {
platform,
dir: dir.to_path_buf(),
opts,
state: State::Fresh,
call: None,
id: 0,
mark: 0,
header: None,
cur: None,
restore: None,
target: Some(target),
done: Vec::new(),
_thread: PhantomData,
})
}
#[must_use]
pub fn restored(&self) -> &[RegionInfo] {
&self.done
}
#[must_use]
pub fn header(&self) -> Option<&ExportHeader> {
self.header.as_ref()
}
#[must_use]
pub fn is_complete(&self) -> bool {
self.state == State::Finished
}
fn fail(&mut self, e: Error, offset: u64) -> SinkError {
if self.state != State::Finished {
self.state = State::Failed;
}
let shown = shown(&e);
let ended = crate::pace::admissions_ended() != self.mark;
if let Some(c) = &self.call {
if !ended {
c.part_failed(e, offset);
}
}
self.cur = None;
self.restore = None;
shown
}
fn refuse(&mut self, offset: u64) -> SinkError {
self.fail(invalid(), offset)
}
fn begin_run(&mut self, header: &ExportHeader) -> Result<(), Error> {
let call = match call::current() {
Some(c) => {
self.id = c.sink_bound();
c
}
None => CallState::detached(),
};
self.call = Some(Rc::clone(&call));
check_header(header)?;
self.header = Some(header.clone());
let Some(target) = self.target.as_ref() else {
return Err(invalid());
};
self.restore = Some(Restore::create(
&self.platform,
&self.dir,
target,
header,
&self.opts.store,
&call,
)?);
Ok(())
}
fn region_run(&mut self, info: &RegionInfo) -> Result<(), Error> {
let Some(restore) = self.restore.as_mut() else {
return Err(invalid());
};
restore.admit(info)?;
let cur = match info.kind {
RegionKind::Slot => Cur::Slot(Vec::new()),
_ => Cur::Area(Box::new(restore.region(info)?)),
};
self.cur = Some((info.clone(), cur));
Ok(())
}
fn written(&self) -> u64 {
match &self.cur {
Some((_, Cur::Area(p))) => p.written(),
_ => 0,
}
}
fn end_run(&mut self) -> Result<(), Error> {
let Some((info, cur)) = self.cur.as_mut() else {
return Err(invalid());
};
match cur {
Cur::Area(p) => {
let _live = p.finish()?;
}
Cur::Slot(object) => match self.restore.as_ref() {
Some(r) => r.slot(info, object)?,
None => return Err(invalid()),
},
}
if let Some((info, _)) = self.cur.take() {
self.done.push(info);
}
Ok(())
}
fn finish_run(&mut self) -> Result<(), Error> {
let (Some(restore), Some(target)) = (self.restore.take(), self.target.as_ref()) else {
return Err(invalid());
};
restore.close()?;
target.commit(&self.platform)
}
}
impl<P: Platform + Clone> ExportSink for StoreSink<P>
where
P::Queue: Send,
{
fn begin(&mut self, header: &ExportHeader) -> Result<(), SinkError> {
self.mark = crate::pace::admissions_ended();
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> {
self.mark = crate::pace::admissions_ended();
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> {
self.mark = crate::pace::admissions_ended();
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));
}
let given = match self.cur.as_mut() {
Some((_, Cur::Area(p))) => p.give(bytes),
Some((_, Cur::Slot(object))) => {
object.extend_from_slice(bytes);
Ok(())
}
None => Err(invalid()),
};
drop(chunk);
if let Some(c) = &self.call {
c.wrote(self.id, self.written().min(declared));
}
match given {
Ok(()) => {
self.state = State::InRegion {
declared,
written: written + n,
};
Ok(())
}
Err(e) => {
let at = self.written();
Err(self.fail(e, at))
}
}
}
fn end_region(&mut self) -> Result<(), SinkError> {
self.mark = crate::pace::admissions_ended();
let State::InRegion { declared, written } = self.state else {
return Err(self.refuse(0));
};
if written != declared {
return Err(self.refuse(written));
}
let at = self.written().min(declared);
match self.end_run() {
Ok(()) => {
self.state = State::Ended;
if let Some(c) = &self.call {
c.region_ended(self.id);
}
Ok(())
}
Err(e) => Err(self.fail(e, at)),
}
}
fn finish(&mut self) -> Result<(), SinkError> {
self.mark = crate::pace::admissions_ended();
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)]
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;
#[test]
fn test_an_admission_ended_by_another_part_is_not_the_sink_s_failure() {
let p = SimPlatform::new(SimConfig::volatile(5500));
let s = Store::create(p.clone(), Path::new("/db"), StoreOptions::default()).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 =
StoreSink::create(p.clone(), Path::new("/to"), StoreSinkOptions::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: 4 << 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");
}
sink.mark = crate::pace::admissions_ended();
let e = match sink.cur.as_mut() {
Some((_, Cur::Area(p))) => p.give(&vec![7u8; 2 << 20]).unwrap_err(),
_ => panic!("no fill"),
};
assert_ne!(crate::pace::admissions_ended(), sink.mark);
let _shown = sink.fail(e, 0);
assert_eq!(sink.state, State::Failed);
assert!(call.failure().is_none(), "recorded as the sink's");
sink.mark = crate::pace::admissions_ended();
let _shown = sink.fail(invalid(), 0);
assert!(call.failure().is_some());
drop(held);
}
struct HoldAtEnd {
inner: Box<dyn ExportSink>,
qos: Arc<crate::qos::Qos>,
clock: store_io_platform::Clock,
ends: usize,
swallowed: Vec<SinkError>,
finishes: bool,
}
impl ExportSink for HoldAtEnd {
fn begin(&mut self, header: &ExportHeader) -> Result<(), SinkError> {
self.inner.begin(header)
}
fn region(&mut self, info: &RegionInfo) -> Result<(), SinkError> {
if let Err(e) = self.inner.region(info) {
self.swallowed.push(e);
}
Ok(())
}
fn data(&mut self, chunk: crate::stream::Chunk) -> Result<(), SinkError> {
if let Err(e) = self.inner.data(chunk) {
self.swallowed.push(e);
}
Ok(())
}
fn end_region(&mut self) -> Result<(), SinkError> {
self.ends += 1;
let mut held = Vec::new();
if self.ends == 1 {
let c = call::current().expect("the export's call");
let pace = c.pace_for(&self.qos, &self.clock).expect("paced");
while let Some(h) = pace.try_charge() {
held.push(h);
assert!(held.len() < 1024, "an admission that never refuses");
}
}
let r = self.inner.end_region();
drop(held);
if let Err(e) = r {
self.swallowed.push(e);
}
Ok(())
}
fn finish(&mut self) -> Result<(), SinkError> {
if !self.finishes {
return Ok(());
}
if let Err(e) = self.inner.finish() {
self.swallowed.push(e);
}
Ok(())
}
}
fn two_regions(p: &SimPlatform) -> Store<SimPlatform> {
let s = Store::create(p.clone(), Path::new("/db"), StoreOptions::default()).unwrap();
for (name, len) in [("a", 384u64 << 10), ("b", 8 << 10)] {
let r = s.provision_page_region(name, len).unwrap();
let _d = r
.write_durable(r.pos(0).unwrap(), &vec![7u8; len as usize])
.unwrap();
}
s
}
#[test]
fn test_a_region_a_sink_never_ended_is_not_counted() {
for (seed, file) in [(5510u64, false), (5511, true)] {
let p = SimPlatform::new(SimConfig::volatile(seed));
let s = two_regions(&p);
let inner: Box<dyn ExportSink> = if file {
drop(p.open_dir(Path::new("/out"), true).unwrap());
Box::new(
crate::FileSink::create(
p.clone(),
Path::new("/out"),
crate::FileSinkOptions::default(),
)
.unwrap(),
)
} else {
Box::new(
StoreSink::create(p.clone(), Path::new("/to"), StoreSinkOptions::default())
.unwrap(),
)
};
let mut w = HoldAtEnd {
inner,
qos: Arc::clone(&s.inner.qos),
clock: p.clock(),
ends: 0,
swallowed: Vec::new(),
finishes: true,
};
let e = s.export(&mut w).unwrap_err();
assert!(!w.swallowed.is_empty(), "file {file}: nothing refused");
assert!(!e.report.complete);
assert_eq!(
e.report.regions, 0,
"file {file}: a region never ended counted"
);
}
}
#[test]
fn test_an_unfinished_export_counts_no_region_its_sink_never_ended() {
let p = SimPlatform::new(SimConfig::volatile(5512));
let s = Store::create(p.clone(), Path::new("/db"), StoreOptions::default()).unwrap();
let r = s.provision_page_region("a", 384 << 10).unwrap();
let _d = r
.write_durable(r.pos(0).unwrap(), &vec![7u8; 384 << 10])
.unwrap();
let mut w = HoldAtEnd {
inner: Box::new(
StoreSink::create(p.clone(), Path::new("/to"), StoreSinkOptions::default())
.unwrap(),
),
qos: Arc::clone(&s.inner.qos),
clock: p.clock(),
ends: 0,
swallowed: Vec::new(),
finishes: false,
};
let e = s.export(&mut w).unwrap_err();
assert!(!w.swallowed.is_empty());
assert!(e.sink.is_none(), "{:?}", e.sink);
assert!(!e.report.complete);
assert_eq!(e.report.regions, 0);
}
}