use store_io_core::errno::is_media_error;
use store_io_core::error::{
ByteRange, CorruptionKind, Error, ErrorContext, NotWrittenCause, Op, OsError,
};
use store_io_core::observe::Counter;
use store_io_platform::{IoBuf, Platform, RawResult};
use crate::exec::Pumped;
use crate::frontier::Reservation;
use crate::io::{ctx_range, not_written};
use crate::receipt::{DurableReceipt, WriteTicket};
use crate::store::{LiveRegion, Store};
#[derive(Debug, Clone, Copy)]
pub(crate) enum Wrote {
Append(Reservation),
Page { start: u64, end: u64 },
}
pub(crate) fn settle_write<P: Platform>(
store: &Store<P>,
state: &LiveRegion,
wrote: Wrote,
full: bool,
raw: Option<OsError>,
prefix: &mut Option<u64>,
) -> Result<WriteTicket, Error>
where
P::Queue: Send,
{
match wrote {
Wrote::Append(r) => match state.frontier.as_ref() {
Some(f) if full => {
f.complete(r);
let through = f.completed();
if through >= r.end {
*prefix = Some(through);
}
Ok(store.ticket(state, r.start, r.end))
}
_ => Err(store.unknown(Op::Write, raw, ctx_range(state, r.start, r.data_end))),
},
Wrote::Page { start, end } => {
if full {
Ok(store.ticket(state, start, end))
} else {
Err(store.unknown(Op::Write, raw, ctx_range(state, start, end)))
}
}
}
}
pub(crate) fn settle_pumped<P: Platform>(
store: &Store<P>,
state: &LiveRegion,
wrote: Wrote,
outcome: Pumped,
) -> Result<WriteTicket, Error>
where
P::Queue: Send,
{
let mut no_prefix = None;
match (outcome, wrote) {
(Pumped::All, _) => settle_write(store, state, wrote, true, None, &mut no_prefix),
(Pumped::Refused(raw), Wrote::Page { start, end }) => {
Err(Store::<P>::refused(raw, ctx_range(state, start, end)))
}
(Pumped::Refused(raw) | Pumped::Failed(raw), _) => {
settle_write(store, state, wrote, false, raw, &mut no_prefix)
}
}
}
pub(crate) fn settle_read<P: Platform>(
store: &Store<P>,
state: &LiveRegion,
start: u64,
end: u64,
buf: Option<&IoBuf>,
result: RawResult<usize>,
) -> Result<usize, Error>
where
P::Queue: Send,
{
let c = ctx_range(state, start, end);
let obs = &store.inner.observer;
match result {
Ok(_) if buf.is_none() => Err(not_written(NotWrittenCause::Interrupted, c)),
Ok(n) => {
obs.add(Counter::Reads, 1);
obs.add(Counter::ReadBytes, n as u64);
Ok(n)
}
Err(raw) if is_media_error(raw) => {
obs.add(Counter::MediaErrors, 1);
Err(Error::Corruption {
kind: CorruptionKind::MediaError,
ctx: c,
})
}
Err(raw) => Err(Error::Io {
op: Op::Read,
raw,
ctx: c,
}),
}
}
pub(crate) fn durable_receipt<P: Platform>(
store: &Store<P>,
state: Option<&LiveRegion>,
t: &WriteTicket,
prefix: Option<u64>,
need: u64,
) -> DurableReceipt
where
P::Queue: Send,
{
match (prefix, state) {
(Some(through), Some(state)) => {
let synced = need != u64::MAX;
if let Some(f) = state.frontier.as_ref() {
if synced {
f.publish_synced(through);
} else {
f.publish_durable(through);
}
}
store.receipt(state, 0, through, need, true, synced)
}
_ => store.receipt_for(t, need),
}
}
pub(crate) fn in_range(e: Error, t: &WriteTicket) -> Error {
match e {
Error::DurabilityUnknown { op, raw, .. } => Error::DurabilityUnknown {
op,
raw,
ctx: ErrorContext {
region: Some(t.region),
range: Some(ByteRange {
start: t.start,
end: t.end,
}),
},
},
other => other,
}
}