use std::borrow::Cow;
use std::collections::{hash_map::Entry, BTreeMap, HashMap, VecDeque};
use std::fmt;
use std::future::Future;
use std::path::{PathBuf, MAIN_SEPARATOR, MAIN_SEPARATOR_STR};
use std::pin::Pin;
use std::sync::Arc;
use crate::error;
use crate::io::walk::{DirEntry, FsWalk};
use crate::io::InputStream;
use crate::operation::upload::{Upload, UploadHandle, UploadInput};
use crate::operation::upload_objects::observability::{
emit_event, emit_terminal_summary, UploadObjectsEvent, UploadObjectsStateSnapshot,
};
use crate::operation::DEFAULT_DELIMITER;
use crate::runtime::sync::Mutex;
use crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS;
use crate::transfer::CompositePendingReason;
use crate::transfer::{IoRequest, PollWork, Transfer, TransferContext, TransferId, WorkOutcome};
use crate::types::{FailedTransferPolicy, FailedUpload};
const MAX_PARALLEL_WALKS: usize = 16;
const WALK_BATCH_SIZE: usize = 64;
const MAX_REAP_PER_POLL: usize = 64;
const WALK_LOW_WATER: usize = MAX_PARALLEL_WALKS * WALK_BATCH_SIZE;
#[derive(Debug)]
pub(crate) enum UploadObjectsWork {
AdvanceWalker { slot: Option<WalkSlot> },
JoinChildren { batch: Option<ReapingBatch> },
}
impl UploadObjectsWork {
fn kind(&self) -> &'static str {
match self {
Self::AdvanceWalker { .. } => "advance_walker",
Self::JoinChildren { .. } => "join_children",
}
}
}
pub(crate) struct ChildTransfer {
source_path: PathBuf,
key: String,
handle: UploadHandle,
}
struct ClaimedEntry {
source_path: PathBuf,
key: String,
input: UploadInput,
}
struct Reservation {
transfer: Arc<UploadObjectsTransferInner>,
count: usize,
consumed: bool,
}
impl Reservation {
fn consume(mut self, state: &mut State) {
debug_assert!(
!self.consumed,
"Reservation::consume called on already-consumed reservation"
);
debug_assert!(
state.children_reserved >= self.count,
"children_reserved underflow: have {}, releasing {}",
state.children_reserved,
self.count,
);
state.children_reserved -= self.count;
self.consumed = true;
}
}
impl Drop for Reservation {
fn drop(&mut self) {
if !self.consumed && self.count > 0 {
let mut state = self.transfer.state.lock();
state.children_reserved = state.children_reserved.saturating_sub(self.count);
tracing::warn!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.transfer.ctx.id,
count = self.count,
"Reservation dropped unconsumed; children_reserved recovered"
);
}
}
}
enum SpawnDecision {
Abort,
Batch(Vec<ClaimedEntry>, Reservation),
}
pub(crate) struct ReapingBatch {
transfer: Arc<UploadObjectsTransferInner>,
children: Option<Vec<ChildTransfer>>,
count: usize,
consumed: bool,
}
impl fmt::Debug for ReapingBatch {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ReapingBatch")
.field("count", &self.count)
.field("consumed", &self.consumed)
.field("children_len", &self.children.as_ref().map(|c| c.len()))
.finish_non_exhaustive()
}
}
impl ReapingBatch {
fn take_children(&mut self) -> Vec<ChildTransfer> {
self.children
.take()
.expect("ReapingBatch::take_children called twice or after consume")
}
fn consume(mut self, state: &mut State) {
debug_assert!(
!self.consumed,
"ReapingBatch::consume called on already-consumed batch"
);
debug_assert!(
state.reaping_in_flight >= self.count,
"reaping_in_flight underflow: have {}, releasing {}",
state.reaping_in_flight,
self.count,
);
state.reaping_in_flight -= self.count;
self.consumed = true;
}
}
impl Drop for ReapingBatch {
fn drop(&mut self) {
if !self.consumed {
let mut state = self.transfer.state.lock();
state.reaping_in_flight = state.reaping_in_flight.saturating_sub(self.count);
tracing::warn!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.transfer.ctx.id,
count = self.count,
"ReapingBatch dropped unconsumed; reaping_in_flight recovered"
);
}
}
}
pub(crate) struct WalkSlot {
transfer: Arc<UploadObjectsTransferInner>,
walk_id: u64,
walk: Option<FsWalk>,
consumed: bool,
}
impl fmt::Debug for WalkSlot {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("WalkSlot")
.field("walk_id", &self.walk_id)
.field("consumed", &self.consumed)
.field("walk_present", &self.walk.is_some())
.finish_non_exhaustive()
}
}
impl WalkSlot {
fn take_walk(&mut self) -> FsWalk {
self.walk
.take()
.expect("WalkSlot::take_walk called twice or after consume")
}
fn consume(mut self, state: &mut State, walk_back: Option<FsWalk>) {
debug_assert!(
!self.consumed,
"WalkSlot::consume called on already-consumed slot"
);
debug_assert!(
state.in_flight_walks >= 1,
"in_flight_walks underflow: cannot release without any in flight"
);
state.in_flight_walks -= 1;
if let Some(walk) = walk_back {
state.walks.insert(self.walk_id, walk);
}
self.consumed = true;
}
}
impl Drop for WalkSlot {
fn drop(&mut self) {
if !self.consumed {
let mut state = self.transfer.state.lock();
state.in_flight_walks = state.in_flight_walks.saturating_sub(1);
if let Some(walk) = self.walk.take() {
state.walks.insert(self.walk_id, walk);
}
tracing::warn!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.transfer.ctx.id,
walk_id = self.walk_id,
"WalkSlot dropped unconsumed; in_flight_walks recovered"
);
}
}
}
type OrchestrateOutcome = Result<UploadHandle, crate::error::Error>;
impl fmt::Debug for ChildTransfer {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ChildTransfer")
.field("source_path", &self.source_path)
.field("key", &self.key)
.finish_non_exhaustive()
}
}
struct State {
walks: BTreeMap<u64, FsWalk>,
next_walk_id: u64,
in_flight_walks: usize,
pending_entries: VecDeque<DirEntry>,
children: HashMap<TransferId, ChildTransfer>,
children_reserved: usize,
reaping_in_flight: usize,
failed: Vec<FailedUpload>,
successful_uploads: u64,
derived_keys: Option<HashMap<String, PathBuf>>,
}
impl State {
fn snapshot(&self) -> UploadObjectsStateSnapshot {
UploadObjectsStateSnapshot {
pending_entries: self.pending_entries.len(),
walks: self.walks.len(),
in_flight_walks: self.in_flight_walks,
children: self.children.len(),
children_reserved: self.children_reserved,
reaping_in_flight: self.reaping_in_flight,
successful: self.successful_uploads,
failed: self.failed.len(),
}
}
fn active_children(&self) -> usize {
self.children
.values()
.filter(|c| !c.handle.status().is_terminal())
.count()
}
fn pending_reason(&self, active: bool) -> CompositePendingReason {
if !active {
CompositePendingReason::Draining
} else if self.reaping_in_flight > 0 {
CompositePendingReason::Reaping
} else if !self.pending_entries.is_empty() {
CompositePendingReason::ChildCapacity
} else if !self.walks.is_empty() || self.in_flight_walks > 0 {
CompositePendingReason::Listing
} else {
CompositePendingReason::ChildCompletion
}
}
#[inline]
fn debug_assert_capacity(&self, max: usize) {
let active = self.active_children();
debug_assert!(
active + self.children_reserved <= max,
"upload_objects capacity violated: active={} children_reserved={} max={}",
active,
self.children_reserved,
max,
);
}
}
#[derive(Clone)]
pub(crate) struct UploadObjectsTransfer {
inner: Arc<UploadObjectsTransferInner>,
}
struct UploadObjectsTransferInner {
ctx: TransferContext,
request: Arc<super::UploadObjectsInput>,
state: Mutex<State>,
#[cfg(test)]
last_summary: std::sync::Mutex<Option<crate::transfer::CompositeTransferSummary>>,
}
impl UploadObjectsTransfer {
pub(crate) fn new(
ctx: TransferContext,
request: super::UploadObjectsInput,
walker: FsWalk,
) -> Self {
let mut walks = BTreeMap::new();
walks.insert(0, walker);
let derived_keys = request
.delimiter()
.filter(|delimiter| *delimiter != DEFAULT_DELIMITER && *delimiter != MAIN_SEPARATOR_STR)
.map(|_| HashMap::new());
let inner = Arc::new(UploadObjectsTransferInner {
ctx,
request: Arc::new(request),
state: Mutex::new(State {
walks,
next_walk_id: 1,
in_flight_walks: 0,
pending_entries: VecDeque::new(),
children: HashMap::new(),
children_reserved: 0,
reaping_in_flight: 0,
failed: Vec::new(),
derived_keys,
successful_uploads: 0,
}),
#[cfg(test)]
last_summary: std::sync::Mutex::new(None),
});
Self { inner }
}
pub(crate) fn ctx(&self) -> &TransferContext {
&self.inner.ctx
}
pub(crate) fn successful_uploads(&self) -> u64 {
self.inner.state.lock().successful_uploads
}
pub(crate) fn take_failed(&self) -> Vec<FailedUpload> {
std::mem::take(&mut self.inner.state.lock().failed)
}
fn max_concurrent_uploads(&self) -> usize {
self.inner.request.max_concurrent_uploads()
}
fn failure_policy(&self) -> &FailedTransferPolicy {
self.inner.request.failure_policy()
}
#[tracing::instrument(
level = "trace",
target = TARGET_TRANSFER_UPLOAD_OBJECTS,
skip_all,
fields(tid = %self.inner.ctx.id),
)]
pub(crate) fn poll_work(&self) -> PollWork {
let active = self.inner.ctx.is_active();
let mut state = self.inner.state.lock();
if active {
if let Some(work) = self.dispatch_walk(&mut state) {
return work;
}
}
let mut attempted = false;
let mut materialized = false;
if active {
let claim = self.claim_one(&mut state);
match claim {
SpawnDecision::Abort => return PollWork::Done,
SpawnDecision::Batch(claimed, reservation) => {
if !claimed.is_empty() {
attempted = true;
drop(state);
let outcomes: Vec<(OrchestrateOutcome, PathBuf, String)> = claimed
.into_iter()
.map(|claimed| {
let ClaimedEntry {
source_path,
key,
input,
} = claimed;
let outcome = Upload::orchestrate_child(
self.inner.ctx.handle.clone(),
input,
self.inner.ctx.id.id,
);
(outcome, source_path, key)
})
.collect();
state = self.inner.state.lock();
let (abort, inserted) =
self.merge_spawned(&mut state, outcomes, reservation);
if let Some(done) = abort {
return done;
}
self.claim_subtrees(&mut state);
materialized = inserted > 0;
} else {
reservation.consume(&mut state);
}
}
}
}
let reaped = self.drain_terminal_children(&mut state);
if let Some(batch) = reaped {
return PollWork::Ready {
io: IoRequest {
data: Some(Box::new(UploadObjectsWork::JoinChildren {
batch: Some(batch),
})),
},
spawned: materialized,
};
}
if attempted {
return PollWork::Spawned;
}
if let Some(out) = self.check_terminal(&mut state) {
return out;
}
if active {
state.debug_assert_capacity(self.max_concurrent_uploads());
}
let reason = state.pending_reason(active);
self.inner.ctx.set_pending(reason);
PollWork::Pending
}
fn report_terminal(&self, snapshot: UploadObjectsStateSnapshot) {
self.inner.ctx.finalize_terminal_metrics();
if !self.inner.ctx.claim_terminal_report() {
return;
}
let _summary = emit_terminal_summary(&self.inner.ctx, snapshot);
#[cfg(test)]
{
*self.inner.last_summary.lock().expect("lock poisoned") = _summary;
}
}
#[cfg(test)]
pub(crate) fn test_terminal_summary(
&self,
) -> Option<crate::transfer::CompositeTransferSummary> {
self.inner
.last_summary
.lock()
.expect("lock poisoned")
.clone()
}
fn abort(&self, state: &mut State, cause: impl Into<String>) -> PollWork {
let cause = cause.into();
tracing::debug!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.inner.ctx.id,
"upload_objects aborting: {cause}"
);
self.inner.ctx.set_failed(crate::error::Error::new(
crate::error::ErrorKind::ChildOperationFailed,
"upload_objects aborted",
));
self.report_terminal(state.snapshot());
self.inner.ctx.signal_terminal();
PollWork::Done
}
fn drain_terminal_children(&self, state: &mut State) -> Option<ReapingBatch> {
let terminal_ids: Vec<TransferId> = state
.children
.iter()
.filter(|(_, c)| c.handle.status().is_terminal())
.map(|(id, _)| *id)
.take(MAX_REAP_PER_POLL)
.collect();
if terminal_ids.is_empty() {
return None;
}
let drained: Vec<ChildTransfer> = terminal_ids
.into_iter()
.map(|id| state.children.remove(&id).expect("id from current map"))
.collect();
let count = drained.len();
state.reaping_in_flight += count;
emit_event(
&self.inner.ctx,
UploadObjectsEvent::ReapScheduled,
state.snapshot(),
);
Some(ReapingBatch {
transfer: self.inner.clone(),
children: Some(drained),
count,
consumed: false,
})
}
fn claim_one(&self, state: &mut State) -> SpawnDecision {
let max_concurrent_uploads = self.max_concurrent_uploads();
let bucket = self
.inner
.request
.bucket()
.expect("bucket validated by UploadObjectsInputBuilder::build")
.to_string();
let key_prefix = self.inner.request.key_prefix().map(|s| s.to_string());
let delimiter = self.inner.request.delimiter().map(|s| s.to_string());
let active = state.active_children();
if active + state.children_reserved >= max_concurrent_uploads {
let reservation = Reservation {
transfer: self.inner.clone(),
count: 0,
consumed: false,
};
return SpawnDecision::Batch(Vec::new(), reservation);
}
let mut batch: Vec<ClaimedEntry> = Vec::new();
while let Some(entry) = state.pending_entries.pop_front() {
let relative = entry.relative_path().to_string_lossy().to_string();
let key =
match derive_object_key(&relative, key_prefix.as_deref(), delimiter.as_deref()) {
Ok(k) => k.into_owned(),
Err(e) => {
state.failed.push(FailedUpload {
input: None,
error: e,
source_path: Some(entry.path().to_path_buf()),
});
if *self.failure_policy() == FailedTransferPolicy::Abort {
self.abort(state, "key derivation failure");
return SpawnDecision::Abort;
}
continue;
}
};
let stream = match InputStream::read_from()
.path(entry.path())
.metadata(entry.metadata().clone())
.build()
{
Ok(s) => s,
Err(e) => {
state.failed.push(FailedUpload {
input: None,
error: e,
source_path: Some(entry.path().to_path_buf()),
});
if *self.failure_policy() == FailedTransferPolicy::Abort {
self.abort(state, "stream creation failure");
return SpawnDecision::Abort;
}
continue;
}
};
let claimed = match state.derived_keys.as_mut() {
Some(keys) => claim_key(keys, &key, entry.path()),
None => Ok(()),
};
if let Err(e) = claimed {
state.failed.push(FailedUpload {
input: None,
error: e,
source_path: Some(entry.path().to_path_buf()),
});
if *self.failure_policy() == FailedTransferPolicy::Abort {
self.abort(state, "key conflict");
return SpawnDecision::Abort;
}
continue;
}
let input = UploadInput::builder()
.bucket(bucket)
.key(key.clone())
.body(stream)
.build()
.unwrap();
batch.push(ClaimedEntry {
source_path: entry.path().to_path_buf(),
key,
input,
});
break;
}
state.children_reserved += batch.len();
let reservation = Reservation {
transfer: self.inner.clone(),
count: batch.len(),
consumed: false,
};
SpawnDecision::Batch(batch, reservation)
}
fn merge_spawned(
&self,
state: &mut State,
outcomes: Vec<(OrchestrateOutcome, PathBuf, String)>,
reservation: Reservation,
) -> (Option<PollWork>, usize) {
debug_assert_eq!(
outcomes.len(),
reservation.count,
"merge_spawned outcomes ({}) must match reservation count ({})",
outcomes.len(),
reservation.count,
);
let mut aborted_in_batch = false;
let mut abort_result = None;
let mut inserted = 0usize;
for (outcome, source_path, key) in outcomes {
match outcome {
Ok(handle) => {
let child_id = handle.id();
tracing::trace!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.inner.ctx.id,
child_id = %child_id,
key = %key,
"spawned child upload"
);
state.children.insert(
child_id,
ChildTransfer {
source_path,
key,
handle,
},
);
inserted += 1;
}
Err(e) => {
tracing::warn!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.inner.ctx.id,
key = %key,
error = %e,
"failed to spawn child upload"
);
state.failed.push(FailedUpload {
input: None,
error: e,
source_path: Some(source_path),
});
if !aborted_in_batch && *self.failure_policy() == FailedTransferPolicy::Abort {
abort_result = Some(self.abort(state, "orchestration failure"));
aborted_in_batch = true;
}
}
}
}
reservation.consume(state);
(abort_result, inserted)
}
fn claim_subtrees(&self, state: &mut State) {
loop {
if state.walks.len() + state.in_flight_walks >= MAX_PARALLEL_WALKS {
break;
}
let mut claimed_any = false;
let walk_ids: Vec<u64> = state.walks.keys().copied().collect();
for wid in walk_ids {
if state.walks.len() + state.in_flight_walks >= MAX_PARALLEL_WALKS {
break;
}
if let Some(sub) = state.walks.get_mut(&wid).unwrap().try_claim_subtree() {
let new_id = state.next_walk_id;
state.next_walk_id += 1;
tracing::trace!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.inner.ctx.id,
parent_walk_id = wid,
new_walk_id = new_id,
"claimed subtree"
);
state.walks.insert(new_id, sub);
claimed_any = true;
}
}
if !claimed_any {
break;
}
}
}
fn check_terminal(&self, state: &mut State) -> Option<PollWork> {
if !self.inner.ctx.is_active() {
if state.in_flight_walks == 0
&& state.children.is_empty()
&& state.children_reserved == 0
&& state.reaping_in_flight == 0
{
tracing::debug!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.inner.ctx.id,
successful = state.successful_uploads,
failed = state.failed.len(),
"upload_objects terminal (cancelled/failed), signaling",
);
self.report_terminal(state.snapshot());
self.inner.ctx.signal_terminal();
return Some(PollWork::Done);
}
return None;
}
if state.walks.is_empty()
&& state.in_flight_walks == 0
&& state.pending_entries.is_empty()
&& state.children.is_empty()
&& state.children_reserved == 0
&& state.reaping_in_flight == 0
{
let m = self.inner.ctx.metrics();
tracing::debug!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.inner.ctx.id,
successful = state.successful_uploads,
failed = state.failed.len(),
network_tx = m.network_tx,
disk_read = m.disk_read,
"upload_objects complete"
);
self.inner.ctx.set_completed();
self.report_terminal(state.snapshot());
self.inner.ctx.signal_terminal();
return Some(PollWork::Done);
}
None
}
fn dispatch_walk(&self, state: &mut State) -> Option<PollWork> {
if state.pending_entries.len() >= WALK_LOW_WATER {
tracing::trace!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.inner.ctx.id,
pending_entries = state.pending_entries.len(),
"dispatch_walk.none.buffer_full"
);
emit_event(
&self.inner.ctx,
UploadObjectsEvent::WalkDeferredBufferFull,
state.snapshot(),
);
return None;
}
if state.walks.is_empty() && state.in_flight_walks > 0 {
tracing::trace!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.inner.ctx.id,
in_flight_walks = state.in_flight_walks,
"dispatch_walk.none.walks_in_flight"
);
emit_event(
&self.inner.ctx,
UploadObjectsEvent::WalkDeferredWalksInFlight,
state.snapshot(),
);
return None;
}
if state.in_flight_walks >= MAX_PARALLEL_WALKS {
tracing::trace!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.inner.ctx.id,
in_flight_walks = state.in_flight_walks,
MAX_PARALLEL_WALKS,
"dispatch_walk.none.walks_saturated"
);
emit_event(
&self.inner.ctx,
UploadObjectsEvent::WalkDeferredWalksSaturated,
state.snapshot(),
);
return None;
}
if let Some(&walk_id) = state.walks.keys().next() {
let walk = state.walks.remove(&walk_id).unwrap();
state.in_flight_walks += 1;
let slot = WalkSlot {
transfer: self.inner.clone(),
walk_id,
walk: Some(walk),
consumed: false,
};
tracing::trace!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.inner.ctx.id,
walk_id,
"dispatching advance_walker"
);
emit_event(
&self.inner.ctx,
UploadObjectsEvent::WalkDispatched,
state.snapshot(),
);
Some(PollWork::ready(IoRequest {
data: Some(Box::new(UploadObjectsWork::AdvanceWalker {
slot: Some(slot),
})),
}))
} else {
tracing::trace!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.inner.ctx.id,
children = state.children.len(),
children_reserved = state.children_reserved,
in_flight_walks = state.in_flight_walks,
"dispatch_walk.none.no_walks_no_work"
);
emit_event(
&self.inner.ctx,
UploadObjectsEvent::WalkDeferredNoWalk,
state.snapshot(),
);
None
}
}
#[tracing::instrument(
level = "trace",
target = TARGET_TRANSFER_UPLOAD_OBJECTS,
skip_all,
fields(tid = %self.inner.ctx.id, work = tracing::field::Empty),
)]
pub(crate) async fn execute(&self, work: &mut IoRequest) -> WorkOutcome {
let data = work.data_mut::<UploadObjectsWork>();
tracing::Span::current().record("work", data.kind());
match data {
UploadObjectsWork::AdvanceWalker { slot } => {
let slot = slot.take().expect("WalkSlot already taken");
self.execute_advance_walker(slot).await
}
UploadObjectsWork::JoinChildren { batch } => {
let batch = batch.take().expect("batch already taken");
self.execute_join_children(batch).await
}
}
}
async fn execute_advance_walker(&self, mut slot: WalkSlot) -> WorkOutcome {
let walk_id = slot.walk_id;
let mut walk = slot.take_walk();
let ctx = &self.inner.ctx;
tracing::trace!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.inner.ctx.id,
walk_id,
ready_files = walk.ready_files_len(),
pending_dirs = walk.pending_dirs_len(),
"advance_walker start"
);
if !ctx.is_active() {
let mut state = self.inner.state.lock();
slot.consume(&mut state, None);
state.debug_assert_capacity(self.max_concurrent_uploads());
return WorkOutcome::Cancelled;
}
let mut entries = Vec::new();
let mut walk_errors = Vec::new();
let mut fatal_error = None;
for _ in 0..WALK_BATCH_SIZE {
match walk.next().await {
Some(Ok(entry)) => entries.push(entry),
Some(Err(e)) => {
if e.is_fatal() {
fatal_error = Some(e);
break;
}
walk_errors.push(e);
}
None => break,
}
}
let mut state = self.inner.state.lock();
if let Some(fatal) = fatal_error {
tracing::debug!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.inner.ctx.id,
walk_id,
error = %fatal,
"fatal walker error, failing upload_objects"
);
slot.consume(&mut state, None);
ctx.set_failed(fatal);
self.report_terminal(state.snapshot());
ctx.signal_terminal();
return WorkOutcome::Failed {
classification: None,
};
}
let n_entries = entries.len();
state.pending_entries.extend(entries);
for we in walk_errors {
tracing::warn!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.inner.ctx.id,
walk_id,
path = ?we.path(),
error = %we,
"non-fatal walker error recorded"
);
let source_path = we.path().map(|p| p.to_path_buf());
state.failed.push(FailedUpload {
input: None,
error: crate::error::Error::from(we),
source_path,
});
if *self.failure_policy() == FailedTransferPolicy::Abort {
slot.consume(&mut state, None);
self.abort(&mut state, "walker error");
return WorkOutcome::Failed {
classification: None,
};
}
}
let exhausted_now = walk.is_exhausted();
let ready_files_remaining = walk.ready_files_len();
let pending_dirs_remaining = walk.pending_dirs_len();
let walk_back = (!exhausted_now).then_some(walk);
slot.consume(&mut state, walk_back);
tracing::trace!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.inner.ctx.id,
walk_id,
yielded = n_entries,
ready_files = ready_files_remaining,
pending_dirs = pending_dirs_remaining,
exhausted = exhausted_now,
"advance_walker end"
);
if state.walks.is_empty() && state.in_flight_walks == 0 {
emit_event(
&self.inner.ctx,
UploadObjectsEvent::ListingExhausted,
state.snapshot(),
);
}
state.debug_assert_capacity(self.max_concurrent_uploads());
if self.check_terminal(&mut state).is_some() {
drop(state);
return WorkOutcome::Success { data: None };
}
drop(state);
ctx.try_wake();
WorkOutcome::Success { data: None }
}
async fn execute_join_children(&self, mut batch: ReapingBatch) -> WorkOutcome {
let children = batch.take_children();
let n_children = children.len();
tracing::trace!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.inner.ctx.id,
n_children,
"join_children start"
);
let futures = children.into_iter().map(|child| {
let metrics = child.handle.metrics();
let source_path = child.source_path;
let key = child.key;
async move {
let result = child.handle.join().await;
(result, metrics, source_path, key)
}
});
let results = futures_util::future::join_all(futures).await;
let mut state = self.inner.state.lock();
let reaped = results.len();
let mut aborted_in_batch = false;
for (result, metrics, source_path, key) in results {
match result {
Ok(_output) => {
state.successful_uploads += 1;
self.inner.ctx.metrics.record_io(&crate::metrics::IoSample {
network_tx: metrics.network_tx,
network_rx: metrics.network_rx,
disk_read: metrics.disk_read,
disk_write: metrics.disk_write,
});
tracing::trace!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.inner.ctx.id,
key = %key,
"child upload completed"
);
}
Err(e) => {
let active = self.inner.ctx.is_active();
let should_abort = !aborted_in_batch
&& active
&& *self.failure_policy() == FailedTransferPolicy::Abort;
let abort_cause =
should_abort.then(|| format!("child upload failed ({key}): {e}"));
tracing::warn!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.inner.ctx.id,
key = %key,
error = %e,
"child upload failed"
);
state.failed.push(FailedUpload {
input: None,
error: e,
source_path: Some(source_path),
});
if let Some(cause) = abort_cause {
self.abort(&mut state, cause);
aborted_in_batch = true;
}
}
}
}
debug_assert_eq!(reaped, batch.count, "reaped count mismatch");
batch.consume(&mut state);
state.debug_assert_capacity(self.max_concurrent_uploads());
tracing::trace!(
target: crate::telemetry::TARGET_TRANSFER_UPLOAD_OBJECTS,
tid = %self.inner.ctx.id,
reaped,
"join_children end"
);
emit_event(
&self.inner.ctx,
UploadObjectsEvent::ReapCompleted,
state.snapshot(),
);
if self.check_terminal(&mut state).is_some() {
drop(state);
return WorkOutcome::Success { data: None };
}
drop(state);
self.inner.ctx.try_wake();
WorkOutcome::Success { data: None }
}
}
impl fmt::Debug for UploadObjectsTransfer {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("UploadObjectsTransfer")
.field("id", &self.inner.ctx.id)
.finish_non_exhaustive()
}
}
impl Transfer for UploadObjectsTransfer {
fn ctx(&self) -> &TransferContext {
UploadObjectsTransfer::ctx(self)
}
fn poll_work(&self) -> PollWork {
UploadObjectsTransfer::poll_work(self)
}
fn execute<'a>(
&'a self,
work: &'a mut IoRequest,
) -> Pin<Box<dyn Future<Output = WorkOutcome> + Send + 'a>> {
Box::pin(UploadObjectsTransfer::execute(self, work))
}
fn on_terminal(&self) {
let snapshot = self.inner.state.lock().snapshot();
self.report_terminal(snapshot);
}
}
fn claim_key(
derived_keys: &mut HashMap<String, PathBuf>,
key: &str,
path: &std::path::Path,
) -> Result<(), error::Error> {
match derived_keys.entry(key.to_owned()) {
Entry::Occupied(e) => Err(error::invalid_input(format!(
"`{}` derives key `{key}`, already derived from `{}`",
path.display(),
e.get().display()
))),
Entry::Vacant(e) => {
e.insert(path.to_path_buf());
Ok(())
}
}
}
pub(crate) fn derive_object_key<'a>(
relative_filename: &'a str,
object_key_prefix: Option<&str>,
object_key_delimiter: Option<&str>,
) -> Result<Cow<'a, str>, error::Error> {
if let Some(delim) = object_key_delimiter {
if delim != DEFAULT_DELIMITER && relative_filename.contains(delim) {
return Err(error::invalid_input(format!(
"a custom delimiter `{delim}` should not appear in `{relative_filename}`"
)));
}
}
let delim = object_key_delimiter.unwrap_or(DEFAULT_DELIMITER);
let relative_filename = if delim == MAIN_SEPARATOR_STR {
Cow::Borrowed(relative_filename)
} else {
Cow::Owned(relative_filename.replace(MAIN_SEPARATOR, delim))
};
let object_key = if let Some(prefix) = object_key_prefix.filter(|p| !p.is_empty()) {
if prefix.ends_with(delim) {
Cow::Owned(format!("{prefix}{relative_filename}"))
} else {
Cow::Owned(format!("{prefix}{delim}{relative_filename}"))
}
} else {
relative_filename
};
Ok(object_key)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::transfer::TransferContext;
use crate::types::FailedTransferPolicy;
use aws_sdk_s3::operation::put_object::PutObjectOutput;
use aws_smithy_mocks::{mock, mock_client, RuleMode};
use std::fs;
use std::time::Duration;
use tempfile::tempdir;
use tokio::time::timeout;
use crate::io::walk::{FsWalkContext, FsWalker};
#[cfg(target_family = "unix")]
#[test]
fn test_derive_object_key() {
assert_eq!(
"2023/Jan/1.png",
derive_object_key("2023/Jan/1.png", None, None).unwrap()
);
assert_eq!(
"foobar/2023/Jan/1.png",
derive_object_key("2023/Jan/1.png", Some("foobar"), None).unwrap()
);
assert_eq!(
"foobar/2023/Jan/1.png",
derive_object_key("2023/Jan/1.png", Some("foobar/"), None).unwrap()
);
assert_eq!(
"2023-Jan-1.png",
derive_object_key("2023/Jan/1.png", None, Some("-")).unwrap()
);
assert_eq!(
"foobar-2023-Jan-1.png",
derive_object_key("2023/Jan/1.png", Some("foobar"), Some("-")).unwrap()
);
assert_eq!(
"foobar-2023-Jan-1.png",
derive_object_key("2023/Jan/1.png", Some("foobar-"), Some("-")).unwrap()
);
assert_eq!(
"foobar--2023-Jan-1.png",
derive_object_key("2023/Jan/1.png", Some("foobar--"), Some("-")).unwrap()
);
assert_eq!(
"2023/MYLONGDELIMJan/MYLONGDELIM1.png",
derive_object_key("2023/Jan/1.png", None, Some("/MYLONGDELIM")).unwrap()
);
{
use std::error::Error as _;
let err = derive_object_key("2023/Jan-1.png", None, Some("-"))
.err()
.unwrap();
assert_eq!(
"a custom delimiter `-` should not appear in `2023/Jan-1.png`",
format!("{}", err.source().unwrap())
);
}
assert_eq!(
"foo/bar-2023-Jan-1.png",
derive_object_key("2023/Jan/1.png", Some("foo/bar"), Some("-")).unwrap()
);
assert_eq!(
"2023/Jan/1.png",
derive_object_key("2023/Jan/1.png", None, Some(DEFAULT_DELIMITER)).unwrap()
);
}
#[cfg(target_family = "windows")]
#[test]
fn test_derive_object_key() {
assert_eq!(
"2023/Jan/1.png",
derive_object_key("2023\\Jan\\1.png", None, None).unwrap()
);
}
#[test]
fn test_derive_object_key_empty_prefix_adds_no_delimiter() {
let nested = ["2023", "Jan", "1.png"].join(MAIN_SEPARATOR_STR);
for (relative, delimiter, expected) in [
("README.md", None, "README.md"),
("README.md", Some("-"), "README.md"),
(nested.as_str(), None, "2023/Jan/1.png"),
(nested.as_str(), Some("-"), "2023-Jan-1.png"),
] {
assert_eq!(
expected,
derive_object_key(relative, Some(""), delimiter).unwrap(),
"relative={relative:?} delimiter={delimiter:?}"
);
}
}
fn mock_s3_success() -> aws_sdk_s3::Client {
let put = mock!(aws_sdk_s3::Client::put_object)
.then_output(|| PutObjectOutput::builder().e_tag("test-etag").build());
mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[put])
}
fn mock_s3_failure() -> aws_sdk_s3::Client {
let put = mock!(aws_sdk_s3::Client::put_object).then_error(|| {
aws_sdk_s3::operation::put_object::PutObjectError::generic(
aws_sdk_s3::error::ErrorMetadata::builder()
.code("InternalError")
.message("simulated failure")
.build(),
)
});
mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[put])
}
fn setup(
source: &std::path::Path,
policy: FailedTransferPolicy,
s3_client: aws_sdk_s3::Client,
recursive: bool,
) -> (
UploadObjectsTransfer,
crate::transfer::StateMachineTerminalReceiver,
) {
let config = crate::Config::builder()
.sdk_client(s3_client)
.build()
.expect("valid config");
let handle = crate::client::Handle::test_handle_tokio(config);
let input = super::super::UploadObjectsInputBuilder::default()
.bucket("test-bucket")
.source(source)
.failure_policy(policy)
.build()
.unwrap();
let walker = FsWalker::builder()
.recursive(recursive)
.follow_symlinks(true)
.build()
.walk(FsWalkContext::builder().root(source).build());
let (ctx, completion_rx) = TransferContext::new(handle);
let transfer = UploadObjectsTransfer::new(ctx, input, walker);
transfer
.inner
.ctx
.handle
.scheduler
.register_empty_group_for_test(transfer.inner.ctx.id.id);
(transfer, completion_rx)
}
async fn drive_transfer(transfer: &UploadObjectsTransfer) {
loop {
match transfer.poll_work() {
PollWork::Ready { io: mut work, .. } => {
transfer.execute(&mut work).await;
}
PollWork::Spawned => {}
PollWork::Pending => {
tokio::time::sleep(Duration::from_millis(10)).await;
}
PollWork::Done => break,
}
}
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_happy_path_3_files_succeed() {
let dir = tempdir().unwrap();
fs::write(dir.path().join("a.txt"), "hello").unwrap();
fs::write(dir.path().join("b.txt"), "world").unwrap();
fs::write(dir.path().join("c.txt"), "test!").unwrap();
let (transfer, completion_rx) = setup(
dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
timeout(Duration::from_secs(5), async {
drive_transfer(&transfer).await;
let _ = completion_rx.await;
})
.await
.expect("transfer should complete within timeout");
assert_eq!(transfer.successful_uploads(), 3);
assert!(transfer.take_failed().is_empty());
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_nested_recursive() {
let dir = tempdir().unwrap();
fs::write(dir.path().join("top.txt"), "top").unwrap();
fs::create_dir(dir.path().join("sub1")).unwrap();
fs::write(dir.path().join("sub1/a.txt"), "a").unwrap();
fs::create_dir(dir.path().join("sub2")).unwrap();
fs::write(dir.path().join("sub2/b.txt"), "b").unwrap();
let (transfer, completion_rx) = setup(
dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
true,
);
timeout(Duration::from_secs(5), async {
drive_transfer(&transfer).await;
let _ = completion_rx.await;
})
.await
.expect("transfer should complete within timeout");
assert_eq!(transfer.successful_uploads(), 3);
assert!(transfer.take_failed().is_empty());
}
async fn uploaded_keys(key_prefix: &str) -> Vec<String> {
let dir = tempdir().unwrap();
fs::write(dir.path().join("top.txt"), "x").unwrap();
fs::create_dir(dir.path().join("sub")).unwrap();
fs::write(dir.path().join("sub/nested.txt"), "y").unwrap();
let captured: Arc<std::sync::Mutex<Vec<String>>> =
Arc::new(std::sync::Mutex::new(Vec::new()));
let captured_cl = captured.clone();
let put = mock!(aws_sdk_s3::Client::put_object)
.match_requests(move |req| {
if let Some(k) = req.key() {
captured_cl.lock().unwrap().push(k.to_string());
}
true
})
.then_output(|| PutObjectOutput::builder().e_tag("test-etag").build());
let s3_client = mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[put]);
let config = crate::Config::builder()
.sdk_client(s3_client)
.build()
.expect("valid config");
let handle = crate::client::Handle::test_handle_tokio(config);
let input = super::super::UploadObjectsInputBuilder::default()
.bucket("test-bucket")
.source(dir.path())
.failure_policy(FailedTransferPolicy::Continue)
.key_prefix(key_prefix)
.build()
.unwrap();
let walker = FsWalker::builder()
.recursive(true)
.follow_symlinks(true)
.build()
.walk(FsWalkContext::builder().root(dir.path()).build());
let (ctx, completion_rx) = TransferContext::new(handle);
let transfer = UploadObjectsTransfer::new(ctx, input, walker);
transfer
.inner
.ctx
.handle
.scheduler
.register_empty_group_for_test(transfer.inner.ctx.id.id);
timeout(Duration::from_secs(5), async {
drive_transfer(&transfer).await;
let _ = completion_rx.await;
})
.await
.expect("transfer should complete within timeout");
assert_eq!(transfer.successful_uploads(), 2);
let mut keys = captured.lock().unwrap().clone();
keys.sort();
keys
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_keys_derived_correctly_with_prefix() {
assert_eq!(
uploaded_keys("photos/2024").await,
vec![
"photos/2024/sub/nested.txt".to_string(),
"photos/2024/top.txt".to_string(),
]
);
}
async fn upload_names(
names: &[&std::path::Path],
delimiter: Option<&str>,
policy: FailedTransferPolicy,
max_concurrent: usize,
) -> (tempfile::TempDir, UploadObjectsTransfer, Vec<String>) {
let dir = tempdir().unwrap();
for name in names {
let path = dir.path().join(name);
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, "x").unwrap();
}
let captured = Arc::new(std::sync::Mutex::new(Vec::new()));
let captured_cl = captured.clone();
let put = mock!(aws_sdk_s3::Client::put_object)
.match_requests(move |req| {
captured_cl
.lock()
.unwrap()
.push(req.key().unwrap().to_string());
true
})
.then_output(|| PutObjectOutput::builder().e_tag("test-etag").build());
let s3_client = mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[put]);
let handle = crate::client::Handle::test_handle_tokio(
crate::Config::builder()
.sdk_client(s3_client)
.build()
.expect("valid config"),
);
let input = super::super::UploadObjectsInputBuilder::default()
.bucket("test-bucket")
.source(dir.path())
.failure_policy(policy)
.max_concurrent_uploads(max_concurrent)
.set_delimiter(delimiter.map(str::to_string))
.build()
.unwrap();
let walker = FsWalker::builder()
.recursive(true)
.build()
.walk(FsWalkContext::builder().root(dir.path()).build());
let (ctx, completion_rx) = TransferContext::new(handle);
let transfer = UploadObjectsTransfer::new(ctx, input, walker);
transfer
.inner
.ctx
.handle
.scheduler
.register_empty_group_for_test(transfer.inner.ctx.id.id);
timeout(Duration::from_secs(5), async {
drive_transfer(&transfer).await;
let _ = completion_rx.await;
})
.await
.expect("transfer should complete within timeout");
let keys = captured.lock().unwrap().clone();
(dir, transfer, keys)
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_files_deriving_one_key_upload_once() {
let names = [std::path::Path::new("a-/b"), std::path::Path::new("a/-b")];
for (policy, max_concurrent) in [
(FailedTransferPolicy::Continue, 16),
(FailedTransferPolicy::Continue, 1),
(FailedTransferPolicy::Abort, 16),
] {
let (dir, transfer, keys) =
upload_names(&names, Some("--"), policy.clone(), max_concurrent).await;
let abort = policy == FailedTransferPolicy::Abort;
assert_eq!(transfer.ctx().is_failed(), abort, "{policy:?}");
let failed = transfer.take_failed();
assert_eq!(failed.len(), 1, "{policy:?}");
assert_eq!(
failed[0].error().kind(),
&crate::error::ErrorKind::InputInvalid
);
let message = std::error::Error::source(failed[0].error())
.unwrap()
.to_string();
let failed_path = failed[0].source_path().unwrap();
let other = names
.iter()
.map(|n| dir.path().join(n).components().collect::<PathBuf>())
.find(|p| p != failed_path)
.unwrap();
assert!(message.contains(&other.display().to_string()), "{message}");
if !abort {
assert_eq!(transfer.successful_uploads(), 1, "{policy:?}");
assert_eq!(keys, ["a---b"], "{policy:?}");
}
}
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_key_registry_only_for_custom_delimiter() {
let names = [std::path::Path::new("a.txt")];
for (delimiter, tracked) in [
(None, false),
(Some(DEFAULT_DELIMITER), false),
(Some(MAIN_SEPARATOR_STR), false),
(Some("--"), true),
] {
let (_dir, transfer, _) =
upload_names(&names, delimiter, FailedTransferPolicy::Continue, 16).await;
let state = transfer.inner.state.lock();
assert_eq!(state.derived_keys.is_some(), tracked, "{delimiter:?}");
assert_eq!(
state.derived_keys.as_ref().map_or(0, HashMap::len),
usize::from(tracked),
"{delimiter:?}"
);
}
}
#[cfg(all(unix, not(target_os = "macos")))]
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_lone_lossy_name_uploads_under_lossy_key() {
use std::os::unix::ffi::OsStrExt;
let name = std::path::Path::new(std::ffi::OsStr::from_bytes(b"caf\xe9"));
let (_dir, transfer, keys) =
upload_names(&[name], None, FailedTransferPolicy::Continue, 16).await;
assert_eq!(transfer.successful_uploads(), 1);
assert_eq!(keys, ["caf\u{fffd}"]);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_keys_derived_correctly_with_empty_prefix() {
assert_eq!(
uploaded_keys("").await,
vec!["sub/nested.txt".to_string(), "top.txt".to_string()]
);
}
#[cfg(unix)]
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_per_entry_walker_error_continue() {
let dir = tempdir().unwrap();
fs::write(dir.path().join("good.txt"), "ok").unwrap();
std::os::unix::fs::symlink("/nonexistent/target/xyz", dir.path().join("broken")).unwrap();
let (transfer, completion_rx) = setup(
dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
timeout(Duration::from_secs(5), async {
drive_transfer(&transfer).await;
let _ = completion_rx.await;
})
.await
.expect("transfer should complete within timeout");
assert_eq!(transfer.successful_uploads(), 1);
let failed = transfer.take_failed();
assert!(!failed.is_empty());
}
#[cfg(unix)]
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_per_entry_walker_error_abort() {
let dir = tempdir().unwrap();
fs::write(dir.path().join("good.txt"), "ok").unwrap();
std::os::unix::fs::symlink("/nonexistent/target/xyz", dir.path().join("broken")).unwrap();
let (transfer, completion_rx) = setup(
dir.path(),
FailedTransferPolicy::Abort,
mock_s3_success(),
false,
);
timeout(Duration::from_secs(5), async {
drive_transfer(&transfer).await;
let _ = completion_rx.await;
})
.await
.expect("transfer should complete within timeout");
assert!(transfer.ctx().is_failed());
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_child_failure_continue() {
let dir = tempdir().unwrap();
fs::write(dir.path().join("a.txt"), "hello").unwrap();
fs::write(dir.path().join("b.txt"), "world").unwrap();
let (transfer, completion_rx) = setup(
dir.path(),
FailedTransferPolicy::Continue,
mock_s3_failure(),
false,
);
timeout(Duration::from_secs(5), async {
drive_transfer(&transfer).await;
let _ = completion_rx.await;
})
.await
.expect("transfer should complete within timeout");
let failed = transfer.take_failed();
assert!(!failed.is_empty());
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_child_failure_abort() {
let dir = tempdir().unwrap();
fs::write(dir.path().join("a.txt"), "hello").unwrap();
fs::write(dir.path().join("b.txt"), "world").unwrap();
let (transfer, completion_rx) = setup(
dir.path(),
FailedTransferPolicy::Abort,
mock_s3_failure(),
false,
);
timeout(Duration::from_secs(5), async {
drive_transfer(&transfer).await;
let _ = completion_rx.await;
})
.await
.expect("transfer should complete within timeout");
assert!(transfer.ctx().is_failed());
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn pending_reason_follows_parent_state() {
let dir = tempdir().unwrap();
fs::write(dir.path().join("a.txt"), "hello").unwrap();
let (transfer, _completion_rx) = setup(
dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
let mut walk = transfer.inner.state.lock().walks.remove(&0).unwrap();
let entry = walk.next().await.unwrap().unwrap();
let mut state = transfer.inner.state.lock();
state.walks.insert(0, walk);
assert_eq!(
state.pending_reason(false),
CompositePendingReason::Draining
);
assert_eq!(state.pending_reason(true), CompositePendingReason::Listing);
state.reaping_in_flight = 1;
assert_eq!(state.pending_reason(true), CompositePendingReason::Reaping);
state.reaping_in_flight = 0;
state.pending_entries.push_back(entry);
assert_eq!(
state.pending_reason(true),
CompositePendingReason::ChildCapacity
);
state.pending_entries.clear();
let walks = std::mem::take(&mut state.walks);
state.in_flight_walks = 1;
assert_eq!(state.pending_reason(true), CompositePendingReason::Listing);
state.in_flight_walks = 0;
assert_eq!(
state.pending_reason(true),
CompositePendingReason::ChildCompletion
);
state.walks = walks;
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn terminal_summary_reported_once_on_success() {
let dir = tempdir().unwrap();
fs::write(dir.path().join("a.txt"), "hello").unwrap();
fs::write(dir.path().join("b.txt"), "world").unwrap();
let (transfer, completion_rx) = setup(
dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
timeout(Duration::from_secs(5), async {
drive_transfer(&transfer).await;
let _ = completion_rx.await;
})
.await
.expect("transfer should complete within timeout");
let summary = transfer
.test_terminal_summary()
.expect("terminal summary reported");
assert_eq!(summary.outcome, crate::transfer::TerminalOutcome::Completed);
assert_eq!(summary.successful, 2);
assert_eq!(summary.failed, 0);
transfer.inner.state.lock().successful_uploads = 99;
Transfer::on_terminal(&transfer);
let summary = transfer
.test_terminal_summary()
.expect("terminal summary reported");
assert_eq!(summary.successful, 2, "summary reported more than once");
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn terminal_summary_reported_once_on_failure() {
let dir = tempdir().unwrap();
fs::write(dir.path().join("a.txt"), "hello").unwrap();
fs::write(dir.path().join("b.txt"), "world").unwrap();
let (transfer, completion_rx) = setup(
dir.path(),
FailedTransferPolicy::Abort,
mock_s3_failure(),
false,
);
timeout(Duration::from_secs(5), async {
drive_transfer(&transfer).await;
let _ = completion_rx.await;
})
.await
.expect("transfer should complete within timeout");
let first = transfer
.test_terminal_summary()
.expect("terminal summary reported");
assert_eq!(first.outcome, crate::transfer::TerminalOutcome::Failed);
assert!(first.error_kind.is_some());
transfer.inner.state.lock().successful_uploads = 99;
Transfer::on_terminal(&transfer);
let summary = transfer
.test_terminal_summary()
.expect("terminal summary reported");
assert_eq!(
summary.successful, first.successful,
"summary reported more than once"
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn terminal_summary_reported_once_on_cancel() {
let dir = tempdir().unwrap();
fs::write(dir.path().join("a.txt"), "hello").unwrap();
let (transfer, _completion_rx) = setup(
dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
transfer.inner.ctx.set_cancelled();
Transfer::on_terminal(&transfer);
let summary = transfer
.test_terminal_summary()
.expect("terminal summary reported");
assert_eq!(summary.outcome, crate::transfer::TerminalOutcome::Cancelled);
assert_eq!(summary.successful, 0);
transfer.inner.state.lock().successful_uploads = 99;
Transfer::on_terminal(&transfer);
let summary = transfer
.test_terminal_summary()
.expect("terminal summary reported");
assert_eq!(summary.successful, 0, "summary reported more than once");
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_cancellation() {
let dir = tempdir().unwrap();
for i in 0..50 {
fs::write(dir.path().join(format!("file_{i}.txt")), "data").unwrap();
}
let (transfer, completion_rx) = setup(
dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
transfer.ctx().set_cancelled();
transfer.ctx().try_wake();
timeout(Duration::from_secs(5), async {
drive_transfer(&transfer).await;
let _ = completion_rx.await;
})
.await
.expect("transfer should reach terminal state within timeout");
assert!(!transfer.ctx().is_active());
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_empty_directory() {
let dir = tempdir().unwrap();
let (transfer, completion_rx) = setup(
dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
timeout(Duration::from_secs(5), async {
drive_transfer(&transfer).await;
let _ = completion_rx.await;
})
.await
.expect("transfer should complete within timeout");
assert_eq!(transfer.successful_uploads(), 0);
assert!(transfer.take_failed().is_empty());
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_reservation_consume_decrements_counter() {
let temp_dir = tempdir().unwrap();
let (transfer, _rx) = setup(
temp_dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
{
let mut state = transfer.inner.state.lock();
state.children_reserved = 5;
}
let reservation = Reservation {
transfer: transfer.inner.clone(),
count: 5,
consumed: false,
};
{
let mut state = transfer.inner.state.lock();
reservation.consume(&mut state);
assert_eq!(0, state.children_reserved, "consume must decrement");
}
let state = transfer.inner.state.lock();
assert_eq!(
0, state.children_reserved,
"Drop after consume must not double-decrement"
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_reservation_drop_without_consume_recovers_counter() {
let temp_dir = tempdir().unwrap();
let (transfer, _rx) = setup(
temp_dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
{
let mut state = transfer.inner.state.lock();
state.children_reserved = 5;
}
{
let _reservation = Reservation {
transfer: transfer.inner.clone(),
count: 5,
consumed: false,
};
}
let state = transfer.inner.state.lock();
assert_eq!(
0, state.children_reserved,
"Drop on unconsumed Reservation must recover the counter"
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_reservation_drop_underflow_saturates() {
let temp_dir = tempdir().unwrap();
let (transfer, _rx) = setup(
temp_dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
{
let _reservation = Reservation {
transfer: transfer.inner.clone(),
count: 5,
consumed: false,
};
}
let state = transfer.inner.state.lock();
assert_eq!(0, state.children_reserved, "Drop must saturate, not panic");
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_reaping_batch_consume_decrements_counter() {
let temp_dir = tempdir().unwrap();
let (transfer, _rx) = setup(
temp_dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
{
let mut state = transfer.inner.state.lock();
state.reaping_in_flight = 3;
}
let batch = ReapingBatch {
transfer: transfer.inner.clone(),
children: Some(Vec::new()),
count: 3,
consumed: false,
};
{
let mut state = transfer.inner.state.lock();
batch.consume(&mut state);
assert_eq!(0, state.reaping_in_flight, "consume must decrement");
}
let state = transfer.inner.state.lock();
assert_eq!(
0, state.reaping_in_flight,
"Drop after consume must not double-decrement"
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_reaping_batch_drop_without_consume_recovers_counter() {
let temp_dir = tempdir().unwrap();
let (transfer, _rx) = setup(
temp_dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
{
let mut state = transfer.inner.state.lock();
state.reaping_in_flight = 3;
}
{
let _batch = ReapingBatch {
transfer: transfer.inner.clone(),
children: Some(Vec::new()),
count: 3,
consumed: false,
};
}
let state = transfer.inner.state.lock();
assert_eq!(
0, state.reaping_in_flight,
"Drop on unconsumed ReapingBatch must recover the counter"
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_reaping_batch_take_children_then_consume() {
let temp_dir = tempdir().unwrap();
let (transfer, _rx) = setup(
temp_dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
{
let mut state = transfer.inner.state.lock();
state.reaping_in_flight = 2;
}
let mut batch = ReapingBatch {
transfer: transfer.inner.clone(),
children: Some(Vec::new()),
count: 2,
consumed: false,
};
let _children = batch.take_children();
{
let mut state = transfer.inner.state.lock();
batch.consume(&mut state);
assert_eq!(0, state.reaping_in_flight);
}
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_walk_slot_consume_decrements_and_reinserts() {
let temp_dir = tempdir().unwrap();
let (transfer, _rx) = setup(
temp_dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
let (walk_id, walk) = {
let mut state = transfer.inner.state.lock();
let walk_id = *state.walks.keys().next().unwrap();
let walk = state.walks.remove(&walk_id).unwrap();
state.in_flight_walks = 1;
(walk_id, walk)
};
let mut slot = WalkSlot {
transfer: transfer.inner.clone(),
walk_id,
walk: Some(walk),
consumed: false,
};
let walk = slot.take_walk();
{
let mut state = transfer.inner.state.lock();
slot.consume(&mut state, Some(walk));
assert_eq!(0, state.in_flight_walks);
assert!(
state.walks.contains_key(&walk_id),
"walker must be re-inserted on normal-completion consume"
);
}
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_walk_slot_consume_drops_walker_on_failure() {
let temp_dir = tempdir().unwrap();
let (transfer, _rx) = setup(
temp_dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
let (walk_id, walk) = {
let mut state = transfer.inner.state.lock();
let walk_id = *state.walks.keys().next().unwrap();
let walk = state.walks.remove(&walk_id).unwrap();
state.in_flight_walks = 1;
(walk_id, walk)
};
let mut slot = WalkSlot {
transfer: transfer.inner.clone(),
walk_id,
walk: Some(walk),
consumed: false,
};
let _walk = slot.take_walk();
{
let mut state = transfer.inner.state.lock();
slot.consume(&mut state, None);
assert_eq!(0, state.in_flight_walks);
assert!(
!state.walks.contains_key(&walk_id),
"walker must be dropped on failure-path consume"
);
}
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_walk_slot_drop_without_consume_recovers_counter_and_walker() {
let temp_dir = tempdir().unwrap();
let (transfer, _rx) = setup(
temp_dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
let (walk_id, walk) = {
let mut state = transfer.inner.state.lock();
let walk_id = *state.walks.keys().next().unwrap();
let walk = state.walks.remove(&walk_id).unwrap();
state.in_flight_walks = 1;
(walk_id, walk)
};
{
let _slot = WalkSlot {
transfer: transfer.inner.clone(),
walk_id,
walk: Some(walk),
consumed: false,
};
}
let state = transfer.inner.state.lock();
assert_eq!(
0, state.in_flight_walks,
"Drop on unconsumed WalkSlot must recover the counter"
);
assert!(
state.walks.contains_key(&walk_id),
"Drop must re-insert the walker when take_walk wasn't called"
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_walk_slot_drop_after_take_walk_recovers_counter_only() {
let temp_dir = tempdir().unwrap();
let (transfer, _rx) = setup(
temp_dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
let (walk_id, walk) = {
let mut state = transfer.inner.state.lock();
let walk_id = *state.walks.keys().next().unwrap();
let walk = state.walks.remove(&walk_id).unwrap();
state.in_flight_walks = 1;
(walk_id, walk)
};
{
let mut slot = WalkSlot {
transfer: transfer.inner.clone(),
walk_id,
walk: Some(walk),
consumed: false,
};
let _walk = slot.take_walk();
}
let state = transfer.inner.state.lock();
assert_eq!(
0, state.in_flight_walks,
"Drop must recover the counter even after take_walk"
);
assert!(
!state.walks.contains_key(&walk_id),
"walker is lost when dropped after take_walk; nothing to re-insert"
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_walk_slot_drop_underflow_saturates() {
let temp_dir = tempdir().unwrap();
let (transfer, _rx) = setup(
temp_dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
let (walk_id, walk) = {
let mut state = transfer.inner.state.lock();
let walk_id = *state.walks.keys().next().unwrap();
let walk = state.walks.remove(&walk_id).unwrap();
(walk_id, walk)
};
{
let _slot = WalkSlot {
transfer: transfer.inner.clone(),
walk_id,
walk: Some(walk),
consumed: false,
};
}
let state = transfer.inner.state.lock();
assert_eq!(
0, state.in_flight_walks,
"Drop must saturate at 0, not panic"
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_single_ticket_500_files_completes() {
let dir = tempdir().unwrap();
for i in 0..500 {
fs::write(dir.path().join(format!("file{i:04}.bin")), "data").unwrap();
}
let (transfer, completion_rx) = setup(
dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
timeout(Duration::from_secs(30), async {
drive_transfer(&transfer).await;
let _ = completion_rx.await;
})
.await
.expect("500-file upload must complete without stalling");
assert_eq!(transfer.successful_uploads(), 500);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_backstop_limits_in_flight_children() {
let dir = tempdir().unwrap();
let max_concurrent: usize = 4;
for i in 0..20 {
fs::write(dir.path().join(format!("f{i:02}.txt")), "abc").unwrap();
}
let config = crate::Config::builder()
.sdk_client(mock_s3_success())
.build()
.expect("valid config");
let handle = crate::client::Handle::test_handle_tokio(config);
let input = super::super::UploadObjectsInputBuilder::default()
.bucket("test-bucket")
.source(dir.path())
.failure_policy(FailedTransferPolicy::Continue)
.max_concurrent_uploads(max_concurrent)
.build()
.unwrap();
let walker = FsWalker::builder()
.recursive(false)
.follow_symlinks(true)
.build()
.walk(FsWalkContext::builder().root(dir.path()).build());
let (ctx, completion_rx) = TransferContext::new(handle);
let transfer = UploadObjectsTransfer::new(ctx, input, walker);
transfer
.inner
.ctx
.handle
.scheduler
.register_empty_group_for_test(transfer.inner.ctx.id.id);
let mut max_observed: usize = 0;
timeout(Duration::from_secs(10), async {
loop {
{
let state = transfer.inner.state.lock();
let active = state.active_children() + state.children_reserved;
if active > max_observed {
max_observed = active;
}
}
match transfer.poll_work() {
PollWork::Ready { io: mut work, .. } => {
transfer.execute(&mut work).await;
}
PollWork::Spawned => {}
PollWork::Pending => {
tokio::time::sleep(Duration::from_millis(5)).await;
}
PollWork::Done => break,
}
}
let _ = completion_rx.await;
})
.await
.expect("transfer should complete within timeout");
assert_eq!(transfer.successful_uploads(), 20);
assert!(
max_observed <= max_concurrent,
"in-flight children ({max_observed}) must not exceed backstop ({max_concurrent})"
);
}
#[cfg(target_family = "unix")]
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_pre_orchestration_failure_continue_does_not_hang() {
let dir = tempdir().unwrap();
fs::write(dir.path().join("bad-file.txt"), "fail").unwrap();
fs::write(dir.path().join("good.txt"), "ok").unwrap();
let config = crate::Config::builder()
.sdk_client(mock_s3_success())
.build()
.expect("valid config");
let handle = crate::client::Handle::test_handle_tokio(config);
let input = super::super::UploadObjectsInputBuilder::default()
.bucket("test-bucket")
.source(dir.path())
.failure_policy(FailedTransferPolicy::Continue)
.delimiter("-") .build()
.unwrap();
let walker = FsWalker::builder()
.recursive(false)
.follow_symlinks(true)
.build()
.walk(FsWalkContext::builder().root(dir.path()).build());
let (ctx, completion_rx) = TransferContext::new(handle);
let transfer = UploadObjectsTransfer::new(ctx, input, walker);
transfer
.inner
.ctx
.handle
.scheduler
.register_empty_group_for_test(transfer.inner.ctx.id.id);
timeout(Duration::from_secs(5), async {
drive_transfer(&transfer).await;
let _ = completion_rx.await;
})
.await
.expect("transfer must complete; a regression hangs here");
assert_eq!(transfer.successful_uploads(), 1);
let failed = transfer.take_failed();
assert_eq!(failed.len(), 1);
}
#[cfg(target_family = "unix")]
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_pre_orchestration_failure_abort_terminates() {
let dir = tempdir().unwrap();
fs::write(dir.path().join("bad-file.txt"), "fail").unwrap();
fs::write(dir.path().join("good.txt"), "ok").unwrap();
let config = crate::Config::builder()
.sdk_client(mock_s3_success())
.build()
.expect("valid config");
let handle = crate::client::Handle::test_handle_tokio(config);
let input = super::super::UploadObjectsInputBuilder::default()
.bucket("test-bucket")
.source(dir.path())
.failure_policy(FailedTransferPolicy::Abort)
.delimiter("-")
.build()
.unwrap();
let walker = FsWalker::builder()
.recursive(false)
.follow_symlinks(true)
.build()
.walk(FsWalkContext::builder().root(dir.path()).build());
let (ctx, completion_rx) = TransferContext::new(handle);
let transfer = UploadObjectsTransfer::new(ctx, input, walker);
transfer
.inner
.ctx
.handle
.scheduler
.register_empty_group_for_test(transfer.inner.ctx.id.id);
timeout(Duration::from_secs(5), async {
drive_transfer(&transfer).await;
let _ = completion_rx.await;
})
.await
.expect("transfer should abort within timeout");
assert!(transfer.ctx().is_failed());
let failed = transfer.take_failed();
assert!(!failed.is_empty());
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_reap_is_continuous_not_batched() {
let dir = tempdir().unwrap();
for i in 0..300 {
fs::write(dir.path().join(format!("f{i:04}.txt")), "x").unwrap();
}
let (transfer, completion_rx) = setup(
dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
let mut fused_reap_spawn = 0usize;
let mut max_terminal_backlog = 0usize;
timeout(Duration::from_secs(30), async {
loop {
let terminal_before = {
let state = transfer.inner.state.lock();
state
.children
.values()
.filter(|c| c.handle.status().is_terminal())
.count()
};
max_terminal_backlog = max_terminal_backlog.max(terminal_before);
match transfer.poll_work() {
PollWork::Ready {
io: mut work,
spawned,
} => {
if spawned {
fused_reap_spawn += 1;
}
transfer.execute(&mut work).await;
}
PollWork::Spawned => {}
PollWork::Pending => {
tokio::time::sleep(Duration::from_millis(5)).await;
}
PollWork::Done => break,
}
}
let _ = completion_rx.await;
})
.await
.expect("transfer should complete within timeout");
assert_eq!(transfer.successful_uploads(), 300);
let _ = (max_terminal_backlog, fused_reap_spawn);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_inactive_drains_outstanding_walk_before_terminal() {
let dir = tempdir().unwrap();
fs::write(dir.path().join("a.txt"), "x").unwrap();
let (transfer, _rx) = setup(
dir.path(),
FailedTransferPolicy::Continue,
mock_s3_success(),
false,
);
let w1 = transfer.poll_work();
assert!(
matches!(w1, PollWork::Ready { .. }),
"first poll should dispatch a walker advance, got {w1:?}"
);
assert_eq!(
transfer.inner.state.lock().in_flight_walks,
1,
"a walker advance should be in flight"
);
transfer.ctx().set_cancelled();
let w2 = transfer.poll_work();
assert!(
matches!(w2, PollWork::Pending),
"must not terminate (return Done) while a walk is in flight; \
expected Pending, got {w2:?}"
);
drop(w1);
}
}