use super::internal::CopyCancellationGuard;
use super::internal::CopyDeadline;
use super::internal::CopyRecoverySnapshot;
use super::internal::StreamCopyPlan;
use super::internal::from_completed_stats;
use crate::AsyncFileSystem;
use crate::copy::AsyncCopyFailure;
use crate::copy::AsyncCopyOperationState;
use crate::copy::CopyConflictPolicy;
use crate::copy::CopyFailureState;
use crate::copy::CopyOptions;
use crate::copy::CopyOutcome;
use crate::copy::CopyStats;
use crate::copy::internal::from_write_failure_state;
use crate::error::FsError;
use crate::error::FsErrorKind;
use crate::error::FsOperation;
use crate::error::OpenFailureStage;
use crate::metadata::SymlinkPolicy;
use crate::path::Path;
use crate::read::ReadOptions;
use crate::spi::CopyAttempt;
use crate::spi::CopyRequest;
use crate::spi::ProviderOperation;
use crate::spi::ResolvedCopyOptions;
use crate::spi::SpiFuture;
use crate::write::AsyncWriterRecovery;
use crate::write::internal::is_unchanged_open_failure;
use crate::write::internal::open_failure_state;
pub struct AsyncCopyOperation {
pub(crate) file_system: AsyncFileSystem,
source: Path,
target: Path,
options: ResolvedCopyOptions,
state: AsyncCopyOperationState,
writer: Option<AsyncWriterRecovery>,
deadline: CopyDeadline,
recovery: CopyRecoverySnapshot,
}
impl AsyncCopyOperation {
#[must_use]
pub(crate) fn new(
file_system: AsyncFileSystem,
source: Path,
target: Path,
options: CopyOptions,
symlink_policy: SymlinkPolicy,
) -> Self {
Self {
file_system,
source,
target,
deadline: CopyDeadline::new(options.deadline(), std::time::Instant::now),
options: ResolvedCopyOptions::new(options, symlink_policy),
state: AsyncCopyOperationState::Ready,
writer: None,
recovery: CopyRecoverySnapshot::unchanged(),
}
}
#[inline]
#[must_use]
pub const fn source(&self) -> &Path {
&self.source
}
#[inline]
#[must_use]
pub const fn target(&self) -> &Path {
&self.target
}
#[inline]
#[must_use]
pub const fn state(&self) -> AsyncCopyOperationState {
self.state
}
#[inline]
#[must_use]
pub const fn has_recovery(&self) -> bool {
self.writer.is_some()
}
#[inline]
pub fn recovery(&mut self) -> Option<&mut AsyncWriterRecovery> {
self.writer.as_mut()
}
#[inline]
pub fn take_recovery(&mut self) -> Option<AsyncWriterRecovery> {
self.writer.take()
}
pub async fn execute(&mut self) -> Result<CopyOutcome, AsyncCopyFailure> {
if self.state != AsyncCopyOperationState::Ready {
return Err(invalid_state_failure(
&self.source,
&self.target,
self.file_system.properties().info().provider_id(),
self.recovery,
));
}
let Self {
file_system,
source,
target,
options,
state,
writer,
deadline,
recovery,
} = self;
let mut guard = CopyCancellationGuard::start(state, writer, recovery);
let result = execute_copy(file_system, source, target, options, *deadline, guard.writer_mut()).await;
guard.finish(&result);
result
}
}
async fn execute_copy(
filesystem: &AsyncFileSystem,
source: &Path,
target: &Path,
options: &ResolvedCopyOptions,
deadline: CopyDeadline,
writer: &mut Option<AsyncWriterRecovery>,
) -> Result<CopyOutcome, AsyncCopyFailure> {
let caller_options = options.options();
if caller_options.max_entries() == Some(0) {
return Err(filesystem.contextual_copy_failure(
budget_error(source, target, "copy entry limit was exceeded"),
CopyFailureState::Unchanged,
CopyStats::default(),
source,
target,
));
}
if deadline.expired() {
return Err(filesystem.contextual_copy_failure(
budget_error(source, target, "copy deadline was exceeded"),
CopyFailureState::Unchanged,
CopyStats::default(),
source,
target,
));
}
if !filesystem.core().provider_supports(ProviderOperation::TryCopy) {
return stream_copy_fallback(filesystem, source, target, options, deadline, writer).await;
}
match filesystem
.spi()
.try_copy(CopyRequest::new(source, target, options.clone()))
.await
{
Ok(CopyAttempt::Completed(outcome)) => {
let outcome = filesystem.verify_completed_copy(outcome, options.options(), source, target)?;
if deadline.expired() {
return Err(filesystem.contextual_copy_failure(
budget_error(source, target, "copy deadline was exceeded"),
from_completed_stats(outcome.stats()),
*outcome.stats(),
source,
target,
));
}
Ok(outcome)
}
Ok(CopyAttempt::Declined(_)) => {
stream_copy_fallback(filesystem, source, target, options, deadline, writer).await
}
Err(failure) => {
let (error, state, stats) = failure.into_parts();
Err(filesystem.contextual_copy_failure(error, state, stats, source, target))
}
}
}
#[inline]
fn stream_copy_fallback<'a>(
filesystem: &'a AsyncFileSystem,
source: &'a Path,
target: &'a Path,
options: &'a ResolvedCopyOptions,
deadline: CopyDeadline,
writer_slot: &'a mut Option<AsyncWriterRecovery>,
) -> SpiFuture<'a, Result<CopyOutcome, AsyncCopyFailure>> {
Box::pin(async move {
let options = options.options();
let plan = StreamCopyPlan::new(options, filesystem.properties().limits(), source, target);
if let Err(error) = plan.validate_options(filesystem.properties().symlink_policy()) {
return Err(filesystem.contextual_copy_failure(
error,
CopyFailureState::Unchanged,
CopyStats::default(),
source,
target,
));
}
if deadline.expired() {
return Err(filesystem.contextual_copy_failure(
budget_error(source, target, "copy deadline was exceeded"),
CopyFailureState::Unchanged,
CopyStats::default(),
source,
target,
));
}
filesystem
.core()
.require_stream_copy_primitives(source, target)
.map_err(|error| {
filesystem.contextual_copy_failure(
error,
CopyFailureState::Unchanged,
CopyStats::default(),
source,
target,
)
})?;
let metadata = filesystem.stat(source).await.map_err(|error| {
filesystem.contextual_copy_failure(error, CopyFailureState::Unchanged, CopyStats::default(), source, target)
})?;
if deadline.expired() {
return Err(filesystem.contextual_copy_failure(
budget_error(source, target, "copy deadline was exceeded"),
CopyFailureState::Unchanged,
CopyStats::default(),
source,
target,
));
}
if let Err(error) = plan.validate_metadata(&metadata) {
return Err(filesystem.contextual_copy_failure(
error,
CopyFailureState::Unchanged,
CopyStats::default(),
source,
target,
));
}
let mut reader = filesystem
.open_reader(source, ReadOptions::default())
.await
.map_err(|error| {
filesystem.contextual_copy_failure(
error,
CopyFailureState::Unchanged,
CopyStats::default(),
source,
target,
)
})?;
if deadline.expired() {
return Err(filesystem.contextual_copy_failure(
budget_error(source, target, "copy deadline was exceeded"),
CopyFailureState::Unchanged,
CopyStats::default(),
source,
target,
));
}
let writer_options = plan.writer_options();
match filesystem.open_writer(target, writer_options).await {
Ok(writer) => *writer_slot = Some(AsyncWriterRecovery::Opened(Box::new(writer))),
Err(error)
if error.stage() == OpenFailureStage::ProviderOpen
&& error.recovery().is_none()
&& error.error().kind() == FsErrorKind::AlreadyExists
&& is_unchanged_open_failure(error.error())
&& options.conflict() == CopyConflictPolicy::Skip =>
{
let stats = CopyStats {
skipped: 1,
..CopyStats::default()
};
if deadline.expired() {
return Err(filesystem.contextual_copy_failure(
budget_error(source, target, "copy deadline was exceeded"),
CopyFailureState::Unchanged,
stats,
source,
target,
));
}
return Ok(CopyOutcome::streamed_fallback(
stats,
crate::metadata::AchievedAtomicity::NonAtomic,
false,
));
}
Err(error) => {
let (error, stage, recovery) = error.into_parts();
*writer_slot = recovery.map(AsyncWriterRecovery::Rejected);
let state = match stage {
OpenFailureStage::Preflight => CopyFailureState::Unchanged,
OpenFailureStage::ProviderOpen => from_write_failure_state(open_failure_state(&error)),
OpenFailureStage::OutcomeValidation => CopyFailureState::Indeterminate,
};
return Err(filesystem.contextual_copy_failure(error, state, CopyStats::default(), source, target));
}
}
let writer = writer_slot
.as_mut()
.and_then(AsyncWriterRecovery::opened_mut)
.expect("writer is retained before transfer");
let bytes =
super::internal::transfer_stream(filesystem, source, target, &mut reader, writer, &plan, deadline).await?;
super::internal::finish_stream_copy(
filesystem,
source,
target,
writer_slot,
&plan,
deadline,
metadata.kind(),
bytes,
)
.await
})
}
fn budget_error(source: &Path, target: &Path, message: &str) -> FsError {
FsError::new(FsErrorKind::ResourceLimitExceeded, FsOperation::Copy, message)
.with_path(source.clone())
.with_target(target.clone())
}
fn invalid_state_failure(
source: &Path,
target: &Path,
provider: &str,
snapshot: CopyRecoverySnapshot,
) -> AsyncCopyFailure {
AsyncCopyFailure::new(
FsError::new(
FsErrorKind::InvalidState,
FsOperation::Copy,
"copy operation cannot execute in its current state",
)
.with_path(source.clone())
.with_target(target.clone())
.with_provider(provider),
snapshot.state,
snapshot.stats,
)
}
#[cfg(test)]
mod tests {
use std::cell::Cell;
use std::io::Result as IoResult;
use std::pin::Pin;
use std::sync::Arc;
use std::sync::atomic::AtomicUsize;
use std::sync::atomic::Ordering;
use std::task::Context;
use std::task::Poll;
use std::task::Waker;
use std::time::Duration;
use std::time::Instant;
use qubit_io::AsyncInput;
use qubit_io::AsyncOutput;
use super::AsyncCopyOperation;
use super::CopyDeadline;
use crate::copy::AsyncCopyOperationState;
use crate::copy::CopyConflictPolicy;
use crate::copy::CopyFailureState;
use crate::copy::CopyOptions;
use crate::error::FsError;
use crate::error::FsErrorKind;
use crate::error::FsOperation;
use crate::error::FsResult;
use crate::metadata::AchievedAtomicity;
use crate::metadata::FileKind;
use crate::metadata::FileMetadata;
use crate::metadata::FileSystemCapabilities;
use crate::metadata::FileSystemCapability;
use crate::metadata::FileSystemId;
use crate::metadata::FileSystemInfo;
use crate::metadata::FileSystemLimits;
use crate::metadata::OpenedFileInfo;
use crate::metadata::PublicationMethod;
use crate::metadata::SymlinkPolicy;
use crate::metadata::WriteOutcome;
use crate::path::Path;
use crate::path::PathConstraints;
use crate::path::PathSemantics;
use crate::spi::AsyncFileSystemSpi;
use crate::spi::AsyncFileWriteSession;
use crate::spi::OpenReaderRequest;
use crate::spi::OpenWriterRequest;
use crate::spi::OpenedAsyncReader;
use crate::spi::OpenedAsyncWriter;
use crate::spi::ProviderOperation;
use crate::spi::ProviderOperations;
use crate::spi::ProviderProperties;
use crate::spi::SpiFuture;
use crate::spi::StatRequest;
use crate::spi::StatResponse;
use crate::write::WriteAbortOutcome;
use crate::write::WriteFailure;
use crate::write::WriteFailureState;
thread_local! { static NOW: Cell<Option<Instant>> = const { Cell::new(None) }; }
fn test_now() -> Instant {
NOW.with(|now| now.get().expect("test clock initialized"))
}
fn advance_clock() {
NOW.with(|now| {
now.set(Some(
now.get().expect("test clock initialized") + Duration::from_secs(1),
))
});
}
#[derive(Clone, Copy)]
enum SuspendAt {
Flush,
Commit,
}
struct StageSpi {
suspend_at: SuspendAt,
fail_commit: bool,
skip_open: bool,
skip_commit: bool,
abort_outcome: WriteAbortOutcome,
source_len: usize,
write_limit: usize,
write_pending_once: bool,
write_zero: bool,
write_error: bool,
calls: Arc<StageCalls>,
}
#[derive(Default)]
struct StageCalls {
writes: AtomicUsize,
flushes: AtomicUsize,
commits: AtomicUsize,
aborts: AtomicUsize,
}
impl StageSpi {
fn info(&self, path: &Path) -> OpenedFileInfo {
OpenedFileInfo::new(
FileSystemId::new("async-deadline-test").expect("valid id"),
path.clone(),
)
.with_metadata(FileMetadata::new(FileKind::File).with_len(Some(1)))
}
}
impl AsyncFileSystemSpi for StageSpi {
fn properties(&self) -> ProviderProperties {
ProviderProperties::new(
FileSystemInfo::new(
FileSystemId::new("async-deadline-test").expect("valid id"),
"async-deadline-test",
PathSemantics::Hierarchical,
),
ProviderOperations::new()
.with(ProviderOperation::Stat)
.with(ProviderOperation::OpenReader)
.with(ProviderOperation::OpenWriter),
FileSystemCapabilities::new()
.with_guaranteed(FileSystemCapability::Read)
.with_guaranteed(FileSystemCapability::Write),
FileSystemLimits::unknown(),
PathConstraints::absolute(),
SymlinkPolicy::Reject,
)
.expect("valid provider properties")
}
fn stat<'a>(&'a self, request: StatRequest<'a>) -> SpiFuture<'a, FsResult<StatResponse>> {
Box::pin(async move {
Ok(StatResponse::new(
request.path().clone(),
FileMetadata::new(FileKind::File).with_len(Some(1)),
))
})
}
fn open_reader<'a>(&'a self, request: OpenReaderRequest<'a>) -> SpiFuture<'a, FsResult<OpenedAsyncReader>> {
let info = self.info(request.path());
let source_len = self.source_len;
Box::pin(async move {
Ok(OpenedAsyncReader::new(
info,
Box::new(StageReader {
read: false,
source_len,
}),
))
})
}
fn open_writer<'a>(&'a self, request: OpenWriterRequest<'a>) -> SpiFuture<'a, FsResult<OpenedAsyncWriter>> {
let info = self.info(request.path());
let suspend_at = self.suspend_at;
let fail_commit = self.fail_commit;
let skip_open = self.skip_open;
let skip_commit = self.skip_commit;
let abort_outcome = self.abort_outcome;
let write_limit = self.write_limit;
let write_pending_once = self.write_pending_once;
let write_zero = self.write_zero;
let write_error = self.write_error;
let calls = self.calls.clone();
if skip_open {
let mut yielded = false;
return Box::pin(std::future::poll_fn(move |_| {
if !yielded {
yielded = true;
return Poll::Pending;
}
Poll::Ready(Err(FsError::new(
FsErrorKind::AlreadyExists,
FsOperation::OpenWriter,
"skip conflict",
)
.with_effect_state(crate::error::FsEffectState::Unchanged)))
}));
}
Box::pin(async move {
Ok(OpenedAsyncWriter::new(
info,
Box::new(StageWriter {
suspend_at,
fail_commit,
skip_commit,
abort_outcome,
flush_pending: false,
write_limit,
write_pending_once,
write_zero,
write_error,
calls,
}),
))
})
}
}
struct StageReader {
read: bool,
source_len: usize,
}
impl AsyncInput for StageReader {
type Item = u8;
unsafe fn poll_read_unchecked(
mut self: Pin<&mut Self>,
_: &mut Context<'_>,
output: &mut [u8],
index: usize,
count: usize,
) -> Poll<IoResult<usize>> {
let this = self.as_mut().get_mut();
if this.read || count == 0 {
return Poll::Ready(Ok(0));
}
for offset in 0..count.min(this.source_len) {
output[index + offset] = b'x';
}
this.read = true;
Poll::Ready(Ok(count.min(this.source_len)))
}
}
struct StageWriter {
suspend_at: SuspendAt,
fail_commit: bool,
skip_commit: bool,
abort_outcome: WriteAbortOutcome,
flush_pending: bool,
write_limit: usize,
write_pending_once: bool,
write_zero: bool,
write_error: bool,
calls: Arc<StageCalls>,
}
impl AsyncOutput for StageWriter {
type Item = u8;
unsafe fn poll_write_unchecked(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
_: &[u8],
_: usize,
count: usize,
) -> Poll<IoResult<usize>> {
let this = self.get_mut();
let attempts = this.calls.writes.fetch_add(1, Ordering::SeqCst);
if this.write_pending_once && attempts == 0 {
cx.waker().wake_by_ref();
return Poll::Pending;
}
if attempts == usize::from(this.write_pending_once) && this.write_limit == 1 && count > 1 {
advance_clock();
}
if this.write_zero {
return Poll::Ready(Ok(0));
}
if this.write_error {
advance_clock();
return Poll::Ready(Err(std::io::Error::other("provider write failed")));
}
Poll::Ready(Ok(count.min(this.write_limit.max(1))))
}
fn poll_flush(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<IoResult<()>> {
let this = self.as_mut().get_mut();
this.calls.flushes.fetch_add(1, Ordering::SeqCst);
if matches!(this.suspend_at, SuspendAt::Flush) && !this.flush_pending {
this.flush_pending = true;
Poll::Pending
} else {
Poll::Ready(Ok(()))
}
}
}
impl AsyncFileWriteSession for StageWriter {
fn commit_async<'a>(mut self: Pin<&'a mut Self>) -> SpiFuture<'a, Result<WriteOutcome, WriteFailure>> {
let this = self.as_mut().get_mut();
this.calls.commits.fetch_add(1, Ordering::SeqCst);
let fail = this.fail_commit;
let skip = this.skip_commit;
let suspend = matches!(this.suspend_at, SuspendAt::Commit) || skip;
let mut yielded = false;
Box::pin(std::future::poll_fn(move |_| {
if suspend && !yielded {
yielded = true;
return Poll::Pending;
}
advance_clock();
Poll::Ready(if skip {
Err(WriteFailure::new(
FsError::new(FsErrorKind::AlreadyExists, FsOperation::CommitWriter, "skip conflict"),
WriteFailureState::RetryableNotPublished,
))
} else if fail {
Err(WriteFailure::new(
FsError::new(FsErrorKind::Io, FsOperation::CommitWriter, "late async commit failure"),
WriteFailureState::RetryableNotPublished,
))
} else {
Ok(WriteOutcome::new(
AchievedAtomicity::NonAtomic,
PublicationMethod::Direct,
))
})
}))
}
fn abort_async<'a>(self: Pin<&'a mut Self>) -> SpiFuture<'a, FsResult<WriteAbortOutcome>> {
let this = self.get_mut();
this.calls.aborts.fetch_add(1, Ordering::SeqCst);
let outcome = this.abort_outcome;
Box::pin(async move {
advance_clock();
Ok(outcome)
})
}
}
struct WriteTestConfig {
suspend_at: SuspendAt,
fail_commit: bool,
source_len: usize,
write_limit: usize,
write_pending_once: bool,
write_zero: bool,
write_error: bool,
with_deadline: bool,
calls: Arc<StageCalls>,
}
impl Default for WriteTestConfig {
fn default() -> Self {
Self {
suspend_at: SuspendAt::Commit,
fail_commit: false,
source_len: 1,
write_limit: 1,
write_pending_once: false,
write_zero: false,
write_error: false,
with_deadline: true,
calls: Arc::new(StageCalls::default()),
}
}
}
fn operation(suspend_at: SuspendAt, fail_commit: bool) -> AsyncCopyOperation {
operation_with_writes(WriteTestConfig {
suspend_at,
fail_commit,
..WriteTestConfig::default()
})
}
fn operation_with_writes(config: WriteTestConfig) -> AsyncCopyOperation {
let with_deadline = config.with_deadline;
let file_system = crate::AsyncFileSystem::from_spi(StageSpi {
suspend_at: config.suspend_at,
fail_commit: config.fail_commit,
skip_open: false,
skip_commit: false,
abort_outcome: WriteAbortOutcome::NotPublished,
source_len: config.source_len,
write_limit: config.write_limit,
write_pending_once: config.write_pending_once,
write_zero: config.write_zero,
write_error: config.write_error,
calls: config.calls,
})
.expect("valid async filesystem");
let start = Instant::now();
NOW.with(|now| now.set(Some(start)));
let mut operation = AsyncCopyOperation::new(
file_system,
Path::parse("/source").expect("source"),
Path::parse("/target").expect("target"),
if with_deadline {
CopyOptions::file().with_deadline(Some(Duration::from_secs(1)))
} else {
CopyOptions::file()
},
SymlinkPolicy::Reject,
);
operation.deadline = CopyDeadline::new(with_deadline.then_some(Duration::from_secs(1)), test_now);
operation
}
fn skip_operation(skip_open: bool, abort_outcome: WriteAbortOutcome, with_deadline: bool) -> AsyncCopyOperation {
let file_system = crate::AsyncFileSystem::from_spi(StageSpi {
suspend_at: SuspendAt::Commit,
fail_commit: false,
skip_open,
skip_commit: !skip_open,
abort_outcome,
source_len: 1,
write_limit: usize::MAX,
write_pending_once: false,
write_zero: false,
write_error: false,
calls: Arc::new(StageCalls::default()),
})
.expect("valid async filesystem");
let start = Instant::now();
NOW.with(|now| now.set(Some(start)));
let mut options = CopyOptions::default().with_conflict(CopyConflictPolicy::Skip);
if with_deadline {
options = options.with_deadline(Some(Duration::from_secs(1)));
}
let mut operation = AsyncCopyOperation::new(
file_system,
Path::parse("/source").expect("source"),
Path::parse("/target").expect("target"),
options,
SymlinkPolicy::Reject,
);
if with_deadline {
operation.deadline = CopyDeadline::new(Some(Duration::from_secs(1)), test_now);
}
operation
}
#[test]
fn test_async_copy_deadline_after_flush_preserves_indeterminate_recovery() {
let mut operation = operation(SuspendAt::Flush, false);
let mut future = Box::pin(operation.execute());
let mut context = Context::from_waker(Waker::noop());
assert!(
future.as_mut().poll(&mut context).is_pending(),
"flush must suspend on first poll"
);
advance_clock();
let failure = match future.as_mut().poll(&mut context) {
Poll::Ready(Err(failure)) => failure,
_ => panic!("expired flush must fail"),
};
drop(future);
assert_eq!(CopyFailureState::Indeterminate, failure.state());
assert_eq!(1, failure.partial_stats().bytes);
assert!(operation.has_recovery());
assert_eq!(
AsyncCopyOperationState::Failed(CopyFailureState::Indeterminate),
operation.state()
);
}
#[test]
fn test_async_copy_deadline_after_commit_is_published_without_recovery() {
let mut operation = operation(SuspendAt::Commit, false);
let mut future = Box::pin(operation.execute());
let mut context = Context::from_waker(Waker::noop());
assert!(
future.as_mut().poll(&mut context).is_pending(),
"commit must suspend on first poll"
);
advance_clock();
let failure = match future.as_mut().poll(&mut context) {
Poll::Ready(Err(failure)) => failure,
_ => panic!("expired commit must fail"),
};
drop(future);
assert_eq!(CopyFailureState::Published, failure.state());
assert_eq!(1, failure.partial_stats().bytes);
assert!(!operation.has_recovery());
}
#[test]
fn test_async_copy_deadline_preserves_late_provider_commit_error() {
let mut operation = operation(SuspendAt::Commit, true);
let mut future = Box::pin(operation.execute());
let mut context = Context::from_waker(Waker::noop());
assert!(future.as_mut().poll(&mut context).is_pending());
advance_clock();
let failure = match future.as_mut().poll(&mut context) {
Poll::Ready(Err(failure)) => failure,
_ => panic!("provider error must win"),
};
drop(future);
assert_eq!(FsErrorKind::Io, failure.error().kind());
assert_eq!(CopyFailureState::Unchanged, failure.state());
}
#[test]
fn test_async_copy_deadline_after_open_skip_preserves_skipped_stats() {
let mut operation = skip_operation(true, WriteAbortOutcome::NotPublished, true);
let mut future = Box::pin(operation.execute());
let mut context = Context::from_waker(Waker::noop());
assert!(
future.as_mut().poll(&mut context).is_pending(),
"provider open must suspend first"
);
advance_clock();
let failure = match future.as_mut().poll(&mut context) {
Poll::Ready(Err(failure)) => failure,
_ => panic!("expired skipped open must fail"),
};
drop(future);
assert_eq!(CopyFailureState::Unchanged, failure.state());
assert_eq!(1, failure.partial_stats().skipped);
assert!(!operation.has_recovery());
}
#[test]
fn test_async_copy_deadline_after_skip_abort_keeps_abort_publication_state() {
for abort_outcome in [WriteAbortOutcome::Published, WriteAbortOutcome::Indeterminate] {
let mut operation = skip_operation(false, abort_outcome, true);
let mut future = Box::pin(operation.execute());
let mut context = Context::from_waker(Waker::noop());
assert!(
future.as_mut().poll(&mut context).is_pending(),
"commit must suspend first"
);
advance_clock();
let failure = match future.as_mut().poll(&mut context) {
Poll::Ready(Err(failure)) => failure,
_ => panic!("expired skipped commit must fail"),
};
drop(future);
assert_eq!(
if abort_outcome == WriteAbortOutcome::Published {
CopyFailureState::Published
} else {
CopyFailureState::Indeterminate
},
failure.state(),
);
assert_eq!(1, failure.partial_stats().skipped);
assert!(!operation.has_recovery());
}
}
#[test]
fn test_async_copy_skip_without_deadline_remains_successful() {
let mut operation = skip_operation(true, WriteAbortOutcome::NotPublished, false);
let mut future = Box::pin(operation.execute());
let mut context = Context::from_waker(Waker::noop());
assert!(
future.as_mut().poll(&mut context).is_pending(),
"provider open must suspend first"
);
let outcome = match future.as_mut().poll(&mut context) {
Poll::Ready(Ok(outcome)) => outcome,
_ => panic!("unbounded skip should succeed"),
};
drop(future);
assert_eq!(1, outcome.stats().skipped);
assert_eq!(AsyncCopyOperationState::Completed, operation.state());
}
#[test]
fn test_async_copy_deadline_after_first_short_write_stops_before_second_write() {
let calls = Arc::new(StageCalls::default());
let mut operation = operation_with_writes(WriteTestConfig {
source_len: 4,
calls: calls.clone(),
..WriteTestConfig::default()
});
let mut future = Box::pin(operation.execute());
let mut context = Context::from_waker(Waker::noop());
let failure = match future.as_mut().poll(&mut context) {
Poll::Ready(Err(failure)) => failure,
_ => panic!("deadline after first short write must fail"),
};
drop(future);
assert_eq!(FsErrorKind::ResourceLimitExceeded, failure.error().kind());
assert_eq!(1, failure.partial_stats().bytes);
assert_eq!(1, calls.writes.load(Ordering::SeqCst));
assert_eq!(0, calls.flushes.load(Ordering::SeqCst));
assert_eq!(0, calls.commits.load(Ordering::SeqCst));
assert_eq!(0, calls.aborts.load(Ordering::SeqCst));
assert_eq!(0, failure.partial_stats().files);
assert!(operation.has_recovery());
}
#[test]
fn test_async_copy_deadline_after_pending_then_short_write_stops_before_second_write() {
let calls = Arc::new(StageCalls::default());
let mut operation = operation_with_writes(WriteTestConfig {
source_len: 4,
write_pending_once: true,
calls: calls.clone(),
..WriteTestConfig::default()
});
let mut future = Box::pin(operation.execute());
let mut context = Context::from_waker(Waker::noop());
assert!(future.as_mut().poll(&mut context).is_pending());
let failure = match future.as_mut().poll(&mut context) {
Poll::Ready(Err(failure)) => failure,
_ => panic!("deadline after pending write must fail"),
};
drop(future);
assert_eq!(FsErrorKind::ResourceLimitExceeded, failure.error().kind());
assert_eq!(1, failure.partial_stats().bytes);
assert_eq!(2, calls.writes.load(Ordering::SeqCst));
assert_eq!(0, calls.flushes.load(Ordering::SeqCst));
assert_eq!(0, calls.commits.load(Ordering::SeqCst));
assert_eq!(0, calls.aborts.load(Ordering::SeqCst));
assert!(operation.has_recovery());
}
#[test]
fn test_async_copy_short_writes_without_deadline_complete() {
let calls = Arc::new(StageCalls::default());
let mut operation = operation_with_writes(WriteTestConfig {
source_len: 4,
with_deadline: false,
calls: calls.clone(),
..WriteTestConfig::default()
});
let mut future = Box::pin(operation.execute());
let mut context = Context::from_waker(Waker::noop());
assert!(future.as_mut().poll(&mut context).is_pending());
let outcome = match future.as_mut().poll(&mut context) {
Poll::Ready(Ok(outcome)) => outcome,
_ => panic!("short writes should complete without a deadline"),
};
assert_eq!(4, outcome.stats().bytes);
assert_eq!(4, calls.writes.load(Ordering::SeqCst));
assert_eq!(1, calls.flushes.load(Ordering::SeqCst));
assert_eq!(1, calls.commits.load(Ordering::SeqCst));
assert_eq!(0, calls.aborts.load(Ordering::SeqCst));
}
#[test]
fn test_async_copy_zero_progress_preserves_write_zero_error() {
let calls = Arc::new(StageCalls::default());
let mut operation = operation_with_writes(WriteTestConfig {
source_len: 4,
write_zero: true,
with_deadline: false,
calls: calls.clone(),
..WriteTestConfig::default()
});
let mut future = Box::pin(operation.execute());
let mut context = Context::from_waker(Waker::noop());
let failure = match future.as_mut().poll(&mut context) {
Poll::Ready(Err(failure)) => failure,
_ => panic!("zero progress must fail"),
};
drop(future);
let source = std::error::Error::source(failure.error()).expect("stream error source");
assert_eq!(
Some(std::io::ErrorKind::WriteZero),
source.downcast_ref::<std::io::Error>().map(std::io::Error::kind),
);
assert_eq!(0, failure.partial_stats().bytes);
assert_eq!(1, calls.writes.load(Ordering::SeqCst));
assert_eq!(0, calls.flushes.load(Ordering::SeqCst));
assert_eq!(0, calls.commits.load(Ordering::SeqCst));
assert_eq!(0, calls.aborts.load(Ordering::SeqCst));
assert!(operation.has_recovery());
}
#[test]
fn test_async_copy_provider_write_error_wins_when_deadline_expires() {
let calls = Arc::new(StageCalls::default());
let mut operation = operation_with_writes(WriteTestConfig {
source_len: 4,
write_error: true,
calls: calls.clone(),
..WriteTestConfig::default()
});
let mut future = Box::pin(operation.execute());
let mut context = Context::from_waker(Waker::noop());
let failure = match future.as_mut().poll(&mut context) {
Poll::Ready(Err(failure)) => failure,
_ => panic!("provider write error must win"),
};
assert_eq!(FsErrorKind::Io, failure.error().kind());
assert_eq!(0, failure.partial_stats().bytes);
assert_eq!(1, calls.writes.load(Ordering::SeqCst));
assert_eq!(0, calls.flushes.load(Ordering::SeqCst));
assert_eq!(0, calls.commits.load(Ordering::SeqCst));
assert_eq!(0, calls.aborts.load(Ordering::SeqCst));
}
#[test]
fn test_async_copy_ready_short_writes_yield_after_sixty_four_calls() {
let calls = Arc::new(StageCalls::default());
let mut operation = operation_with_writes(WriteTestConfig {
source_len: 65,
with_deadline: false,
calls: calls.clone(),
..WriteTestConfig::default()
});
let mut future = Box::pin(operation.execute());
let mut context = Context::from_waker(Waker::noop());
assert!(future.as_mut().poll(&mut context).is_pending());
assert_eq!(64, calls.writes.load(Ordering::SeqCst));
loop {
match future.as_mut().poll(&mut context) {
Poll::Pending => continue,
Poll::Ready(Ok(outcome)) => {
assert_eq!(65, outcome.stats().bytes);
break;
}
Poll::Ready(Err(failure)) => panic!("copy failed: {}", failure.error()),
}
}
assert_eq!(65, calls.writes.load(Ordering::SeqCst));
}
}