use std::cell::Cell;
use std::path::Path;
use store_io_core::error::{Error, ErrorContext, NotWrittenCause, Op};
use store_io_format::meta::RegionKind;
use store_io_platform::Platform;
use crate::call::{self, CallState};
use crate::export::{ExportHeader, ImportSource, RegionInfo, SinkError};
use crate::io::not_written;
use crate::restore::{Restore, check_header, invalid};
use crate::store::StoreOptions;
use crate::target::TargetDir;
#[derive(Debug, Clone, Default)]
#[non_exhaustive]
pub struct ImportOptions {
pub store: StoreOptions,
}
#[derive(Debug, Clone, Default)]
#[non_exhaustive]
pub struct ImportReport {
pub header: Option<ExportHeader>,
pub regions: Vec<RegionInfo>,
pub bytes: u64,
pub index: Option<u32>,
pub region: Option<String>,
pub complete: bool,
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct ImportError {
pub error: Error,
pub source: Option<SinkError>,
pub report: ImportReport,
}
impl ImportError {
#[must_use]
pub fn from_error(error: Error) -> Self {
Self {
error,
source: None,
report: ImportReport::default(),
}
}
}
impl core::fmt::Display for ImportError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "import stopped: {}", self.error)
}
}
impl std::error::Error for ImportError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
Some(&self.error)
}
}
fn sourced(call: &CallState, e: SinkError) -> Error {
if let Some(f) = call.failure() {
return f.error;
}
match e {
SinkError::Io(raw) => Error::Io {
op: Op::Read,
raw,
ctx: ErrorContext::default(),
},
SinkError::Refused | SinkError::Other(_) => {
not_written(NotWrittenCause::Interrupted, ErrorContext::default())
}
}
}
pub fn import<P: Platform + Clone>(
platform: P,
dir: &Path,
source: &mut dyn ImportSource,
opts: ImportOptions,
) -> Result<ImportReport, Box<ImportError>>
where
P::Queue: Send,
{
let call = CallState::detached();
let _bound = call::bind(&call);
let mut report = ImportReport::default();
let from = Cell::new(None);
match import_run(&platform, dir, source, &opts, &call, &from, &mut report) {
Ok(()) => {
report.index = None;
report.region = None;
report.complete = true;
Ok(report)
}
Err(error) => Err(Box::new(ImportError {
error,
source: from.get(),
report,
})),
}
}
fn import_run<P: Platform + Clone>(
platform: &P,
dir: &Path,
source: &mut dyn ImportSource,
opts: &ImportOptions,
call: &CallState,
from: &Cell<Option<SinkError>>,
report: &mut ImportReport,
) -> Result<(), Error>
where
P::Queue: Send,
{
let src = |e: SinkError| {
from.set(Some(e));
sourced(call, e)
};
let header = source.header().map_err(src)?;
report.header = Some(header.clone());
check_header(&header)?;
let target = TargetDir::open(platform, dir)?;
{
let mut dst = Restore::create(platform, dir, &target, &header, &opts.store, call)?;
for i in 0..header.region_count {
report.index = Some(i);
report.region = None;
call.enter(i, report.bytes);
let Some(info) = source.next_region().map_err(src)? else {
return Err(invalid());
};
report.region = Some(info.name.clone());
dst.admit(&info)?;
let n = import_region(&dst, &info, source, &src)?;
report.bytes += n;
report.regions.push(info);
call.leave(i.saturating_add(1));
}
report.index = None;
report.region = None;
if source.next_region().map_err(src)?.is_some() {
return Err(invalid());
}
dst.close()?;
}
target.commit(platform)
}
fn pull(
source: &mut dyn ImportSource,
dst: &mut [u8],
piece: usize,
src: &dyn Fn(SinkError) -> Error,
) -> Result<(), Error> {
let mut done = 0usize;
while done < dst.len() {
let want = (dst.len() - done).min(piece);
let n = source.read(&mut dst[done..done + want]).map_err(src)?;
if n == 0 || n > want {
return Err(invalid());
}
done += n;
}
Ok(())
}
fn ended(source: &mut dyn ImportSource, src: &dyn Fn(SinkError) -> Error) -> Result<(), Error> {
let mut one = [0u8; 1];
match source.read(&mut one).map_err(src)? {
0 => Ok(()),
_ => Err(invalid()),
}
}
fn import_region<P: Platform + Clone>(
dst: &Restore<P>,
info: &RegionInfo,
source: &mut dyn ImportSource,
src: &dyn Fn(SinkError) -> Error,
) -> Result<u64, Error>
where
P::Queue: Send,
{
let len = info.stream_len();
let piece = dst.read_piece();
if info.kind == RegionKind::Slot {
let mut object = vec![0u8; len as usize];
pull(source, &mut object, piece, src)?;
ended(source, src)?;
dst.slot(info, &object)?;
return Ok(len);
}
let mut made = dst.region(info)?;
let mut left = len;
while left > 0 {
let room = made.room()?;
if room.is_empty() {
return Err(crate::store::corrupt());
}
let n = room.len().min(usize::try_from(left).unwrap_or(usize::MAX));
pull(source, &mut room[..n], piece, src)?;
made.filled(n)?;
left -= n as u64;
}
ended(source, src)?;
let _live = made.finish()?;
Ok(len)
}