use std::cmp;
use std::future::Future;
use std::pin::Pin;
use std::sync::{Arc, Mutex};
use std::task::{Context, Poll};
use bytes::BufMut;
use futures_util::future::{select, Either};
use crate::sdk_v1::copy_download_input_fields_to_get_object as copy_fields_to_get_object_request;
use crate::error::{self, ChunkRef, Error};
use crate::operation::download::body::{BodySlot, BodyWriter, ChunkOutput, DrainError, Drained};
use crate::operation::download::checksum::{DownloadIntegrity, RangeCompletion, RangeDigestPlan};
use crate::operation::download::context::{
CompletionClaim, DownloadPendingReason, DownloadState, PendingClaim,
};
use crate::operation::download::discovery::{discover_obj, InitialChunk, ObjectDiscovery};
use crate::operation::download::observability::{
DownloadDestination, DownloadEvent, DownloadExecutionState, DownloadObservability,
DownloadRequestKind, DownloadRequestMeasurement, DownloadStateSnapshot, DownloadTerminalReport,
};
use crate::operation::download::read_ahead::ReadAhead;
use crate::operation::download::recv_buffer::{DrainMode, FillOutcome};
use crate::operation::download::ChunkMetadata;
use crate::operation::download::DownloadInput;
use crate::operation::download::ObjectMetadata;
use crate::runtime::buffer_pool::{
AcquireError, BufferPool, Reservation, ReserveError, SegmentedBytes,
};
use crate::telemetry::TARGET_TRANSFER_DOWNLOAD;
use crate::transfer::{IoRequest, PollWork, Transfer, TransferContext, TransferId, WorkOutcome};
use crate::types::BucketType;
use aws_smithy_observability::unit_of_work::checksums::ChecksumCapture;
use aws_smithy_observability::unit_of_work::Capture;
use aws_smithy_types::error::display::DisplayErrorContext;
use tracing::Instrument;
#[derive(Debug, Clone)]
pub(crate) struct DownloadTransfer {
inner: Arc<DownloadTransferInner>,
}
#[derive(Debug)]
struct DownloadTransferInner {
ctx: TransferContext,
state: Mutex<DownloadState>,
observability: DownloadObservability,
request: Arc<DownloadInput>,
#[allow(dead_code)]
bucket_type: BucketType,
writer: BodyWriter,
read_ahead: ReadAhead,
object_meta: std::sync::OnceLock<ObjectMetadata>,
integrity_checks: std::sync::OnceLock<crate::types::IntegrityChecks>,
expected_download_len: std::sync::OnceLock<u64>,
discovery_notify: tokio::sync::Notify,
listed: Option<super::ListedObject>,
}
#[derive(Debug)]
pub(super) enum DownloadWork {
Discovery,
GetObjectRange {
range: std::ops::RangeInclusive<u64>,
slot: Option<BodySlot>,
etag: Option<Arc<str>>,
digest_plan: RangeDigestPlan,
},
DrainResident,
}
impl DownloadWork {
fn kind(&self) -> &'static str {
match self {
Self::Discovery => "discovery",
Self::GetObjectRange { .. } => "get_object_range",
Self::DrainResident => "drain_resident",
}
}
}
macro_rules! bail_if_terminal {
($self:expr) => {
if !$self.inner.ctx.is_active() {
let _ = $self.decrement_in_flight(0, None);
return WorkOutcome::Cancelled;
}
};
}
impl DownloadTransfer {
pub(crate) fn new(
ctx: TransferContext,
bucket_type: BucketType,
input: DownloadInput,
writer: BodyWriter,
) -> Self {
Self::new_listed(ctx, bucket_type, input, writer, None)
}
pub(crate) fn new_listed(
ctx: TransferContext,
bucket_type: BucketType,
input: DownloadInput,
writer: BodyWriter,
listed: Option<super::ListedObject>,
) -> Self {
let window =
super::read_ahead::resolve_window(input.read_ahead(), ctx.handle.config.read_ahead());
let read_ahead = ReadAhead::with_window(window);
writer.sync_drain_batch(window);
let destination = if writer.has_sink() {
DownloadDestination::File
} else {
DownloadDestination::Stream
};
let observability =
DownloadObservability::new(ctx.handle.config.diagnostics().transfer(), destination);
let inner = Arc::new(DownloadTransferInner {
read_ahead,
ctx,
state: Mutex::new(DownloadState::new()),
observability,
request: Arc::new(input),
bucket_type,
writer,
object_meta: std::sync::OnceLock::new(),
integrity_checks: std::sync::OnceLock::new(),
expected_download_len: std::sync::OnceLock::new(),
discovery_notify: tokio::sync::Notify::new(),
listed,
});
Self { inner }
}
pub(crate) fn ctx(&self) -> &TransferContext {
&self.inner.ctx
}
pub(super) fn listed_object(&self) -> Option<&super::ListedObject> {
self.inner.listed.as_ref()
}
pub(crate) fn start_request(&self, kind: DownloadRequestKind) -> DownloadRequestMeasurement {
self.inner
.observability
.start_request(&self.inner.ctx, kind)
}
fn snapshot(&self, state: &DownloadState) -> DownloadStateSnapshot {
snapshot_state(state, self.inner.read_ahead.window())
}
fn observe_event(&self, event: DownloadEvent, state: &DownloadState) {
let snapshot = self.snapshot(state);
self.inner
.observability
.observe_event(self.inner.ctx.id, event, snapshot);
}
fn report_terminal(&self, state_snapshot: DownloadStateSnapshot) {
self.inner.ctx.finalize_terminal_metrics();
if !self.inner.ctx.claim_terminal_report() {
return;
}
let pending = self.inner.ctx.pending_stats().unwrap_or_default();
let checksum_validation = self
.inner
.integrity_checks
.get()
.map(|checks| checks.checksum_validation().clone());
let _ = self
.inner
.observability
.report_terminal(DownloadTerminalReport {
transfer_id: self.inner.ctx.id,
status: self.inner.ctx.transfer_status(),
error_kind: self.inner.ctx.error_kind(),
metrics: self.inner.ctx.metrics(),
request_total: self.inner.ctx.metrics.request_metrics(),
pending,
checksum_validation,
state_snapshot,
});
}
pub(crate) fn id(&self) -> TransferId {
self.inner.ctx.id
}
pub(crate) fn writer(&self) -> &BodyWriter {
&self.inner.writer
}
#[cfg(test)]
pub(crate) fn read_ahead(&self) -> &ReadAhead {
&self.inner.read_ahead
}
#[cfg(test)]
pub(crate) fn test_terminal_summary(
&self,
) -> Option<crate::operation::download::observability::DownloadTransferSummary> {
self.inner.observability.test_terminal_summary()
}
#[cfg(test)]
pub(crate) fn io_ctl(&self) -> super::handle::DownloadIoCtl<'_> {
super::handle::DownloadIoCtl::for_test(self)
}
pub(crate) fn set_read_ahead(&self, mode: &crate::config::ReadAhead) {
let window = super::read_ahead::window_parts_for(mode);
self.inner.read_ahead.set_window(window);
self.inner.writer.sync_drain_batch(window);
}
pub(crate) fn release_stream_occupancy(&self) {
{
let mut work = self.inner.state.lock().unwrap();
if let DownloadState::Transferring { gate, .. } = &mut *work {
gate.release(1);
}
}
self.inner.ctx.try_wake();
}
pub(crate) fn object_meta(&self) -> Option<&ObjectMetadata> {
self.inner.object_meta.get()
}
pub(crate) fn integrity_checks(&self) -> Option<&crate::types::IntegrityChecks> {
self.inner.integrity_checks.get()
}
pub(crate) fn discovery_notify(&self) -> &tokio::sync::Notify {
&self.inner.discovery_notify
}
fn validation_enabled(&self, input: &DownloadInput) -> bool {
match input.checksum_mode {
Some(crate::model::ChecksumMode::Enabled) => true,
_ => !matches!(
self.ctx()
.s3_client()
.config()
.response_checksum_validation()
.copied()
.unwrap_or_default(),
aws_sdk_s3::config::ResponseChecksumValidation::WhenRequired
),
}
}
#[tracing::instrument(
level = "trace",
target = TARGET_TRANSFER_DOWNLOAD,
skip_all,
fields(tid = %self.id()),
)]
pub(crate) fn poll_work(&self) -> PollWork {
if !self.inner.ctx.is_active() {
tracing::debug!(
target: crate::telemetry::TARGET_TRANSFER_DOWNLOAD,
"not active, returning Done",
);
return PollWork::Done;
}
let mut state = self.inner.state.lock().unwrap();
match &mut *state {
DownloadState::PendingDiscovery => {
*state = DownloadState::DiscoveryInFlight;
self.observe_event(DownloadEvent::DiscoveryScheduled, &state);
PollWork::ready(IoRequest {
data: Some(Box::new(DownloadWork::Discovery)),
})
}
DownloadState::DiscoveryInFlight => {
self.inner.ctx.set_pending(DownloadPendingReason::Discovery);
self.inner
.observability
.observe_state(self.snapshot(&state));
PollWork::Pending
}
DownloadState::Transferring {
remaining,
ranges_in_flight,
drains_in_flight,
etag,
part_size,
gate,
pending,
integrity,
} => {
let slot = if pending.is_some() {
match self.resume_pending_claim(pending) {
Ok(Some(slot)) => slot,
Ok(None) => {
let snapshot = transferring_snapshot(
remaining.as_ref(),
*ranges_in_flight,
gate,
self.inner.read_ahead.window(),
pending.is_some(),
);
return self.poll_memory_blocked(drains_in_flight, snapshot);
}
Err(error) => return self.fail_memory_admission(state, error),
}
} else if let Some(range) = remaining.as_ref() {
let window = self.inner.read_ahead.window();
if !gate.try_issue(window) {
tracing::trace!(
target: crate::telemetry::TARGET_TRANSFER_DOWNLOAD,
issued = gate.issued(),
released = gate.released(),
in_flight = gate.resident(),
window,
"read-ahead gate closed: issuance paused until the consumer drains",
);
let snapshot = transferring_snapshot(
remaining.as_ref(),
*ranges_in_flight,
gate,
window,
pending.is_some(),
);
return self.park(DownloadPendingReason::ReadAhead, snapshot);
}
let range_len = chunk_len(range, *part_size);
match self.reserve_claim(range_len, pending) {
Ok(Some(slot)) => slot,
Ok(None) => {
let snapshot = transferring_snapshot(
remaining.as_ref(),
*ranges_in_flight,
gate,
self.inner.read_ahead.window(),
pending.is_some(),
);
return self.poll_memory_blocked(drains_in_flight, snapshot);
}
Err(error) => return self.fail_memory_admission(state, error),
}
} else if *ranges_in_flight > 0 {
let snapshot = transferring_snapshot(
remaining.as_ref(),
*ranges_in_flight,
gate,
self.inner.read_ahead.window(),
pending.is_some(),
);
return self.park(DownloadPendingReason::RangeCompletion, snapshot);
} else if *drains_in_flight > 0 {
let snapshot = transferring_snapshot(
remaining.as_ref(),
*ranges_in_flight,
gate,
self.inner.read_ahead.window(),
pending.is_some(),
);
return self.park(DownloadPendingReason::DrainCompletion, snapshot);
} else {
unreachable!(
"download completion is claimed by the work item that retires last"
);
};
let part_size = *part_size;
let range = remaining
.as_ref()
.expect("a ready slot implies a remaining range to issue");
let start = *range.start();
let end = *range.end();
let chunk_end = cmp::min(start + part_size - 1, end);
let chunk_range = start..=chunk_end;
*ranges_in_flight += 1;
let all_ranges_issued;
if chunk_end < end {
*remaining = Some((chunk_end + 1)..=end);
all_ranges_issued = false;
} else {
*remaining = None;
all_ranges_issued = true;
tracing::debug!(
target: crate::telemetry::TARGET_TRANSFER_DOWNLOAD,
issued = gate.issued(),
ranges_in_flight = *ranges_in_flight,
"all ranges issued; draining in-flight tail",
);
}
let snapshot = transferring_snapshot(
remaining.as_ref(),
*ranges_in_flight,
gate,
self.inner.read_ahead.window(),
pending.is_some(),
);
self.inner.observability.record_range_scheduled();
self.inner.observability.observe_event(
self.inner.ctx.id,
DownloadEvent::RangeScheduled,
snapshot,
);
if all_ranges_issued {
self.inner.observability.observe_event(
self.inner.ctx.id,
DownloadEvent::AllRangesIssued,
snapshot,
);
}
PollWork::ready(IoRequest {
data: Some(Box::new(DownloadWork::GetObjectRange {
range: chunk_range,
slot: Some(slot),
etag: etag.clone(),
digest_plan: integrity.range_digest_plan(),
})),
})
}
DownloadState::Terminal => PollWork::Done,
}
}
fn park(&self, reason: DownloadPendingReason, snapshot: DownloadStateSnapshot) -> PollWork {
self.inner.ctx.set_pending(reason);
self.inner.observability.observe_state(snapshot);
PollWork::Pending
}
fn poll_memory_blocked(
&self,
drains_in_flight: &mut u32,
snapshot: DownloadStateSnapshot,
) -> PollWork {
if *drains_in_flight == 0 && self.inner.writer.has_drainable_resident() {
*drains_in_flight += 1;
self.inner.observability.observe_event(
self.inner.ctx.id,
DownloadEvent::MemoryReliefScheduled,
snapshot,
);
PollWork::ready(IoRequest {
data: Some(Box::new(DownloadWork::DrainResident)),
})
} else {
self.inner
.ctx
.set_pending(DownloadPendingReason::MemoryAdmission);
self.inner.observability.observe_state(snapshot);
PollWork::Pending
}
}
fn resume_pending_claim(
&self,
pending: &mut Option<PendingClaim>,
) -> Result<Option<BodySlot>, ReserveError> {
let waker = self.inner.ctx.waker();
let mut context = Context::from_waker(&waker);
let reservation =
match Pin::new(&mut pending.as_mut().unwrap().reservation).poll(&mut context) {
Poll::Ready(result) => result?,
Poll::Pending => return Ok(None),
};
let mut claim = pending.take().unwrap();
claim.slot.attach_reservation(reservation);
Ok(Some(claim.slot))
}
fn reserve_claim(
&self,
range_len: usize,
pending: &mut Option<PendingClaim>,
) -> Result<Option<BodySlot>, ReserveError> {
let mut slot = self.inner.writer.claim();
let mut reservation = self.inner.ctx.handle.buffer_pool.reserve(range_len);
let waker = self.inner.ctx.waker();
let mut context = Context::from_waker(&waker);
match Pin::new(&mut reservation).poll(&mut context) {
Poll::Ready(Ok(reservation)) => {
slot.attach_reservation(reservation);
Ok(Some(slot))
}
Poll::Ready(Err(error)) => Err(error),
Poll::Pending => {
*pending = Some(PendingClaim { slot, reservation });
Ok(None)
}
}
}
async fn reserve_discovery_chunk(
&self,
len: usize,
) -> Result<Option<Reservation>, ReserveError> {
let mut reservation = std::pin::pin!(self.inner.ctx.handle.buffer_pool.reserve(len));
loop {
let terminal_wake = self.inner.discovery_notify.notified();
let terminal_wake = std::pin::pin!(terminal_wake);
if !self.inner.ctx.is_active() {
return Ok(None);
}
match select(reservation.as_mut(), terminal_wake).await {
Either::Left((result, _)) => {
tracing::debug!(
target: crate::telemetry::TARGET_SCHEDULING,
tid = %self.inner.ctx.id,
len,
"discovery chunk reservation granted; resuming",
);
return result.map(Some);
}
Either::Right(((), _)) => {}
}
}
}
fn fail_memory_admission(
&self,
state: std::sync::MutexGuard<'_, DownloadState>,
source: ReserveError,
) -> PollWork {
let _ = self.fail(
state,
error::Error::new(error::ErrorKind::RuntimeError, source),
);
PollWork::Done
}
#[tracing::instrument(
level = "trace",
target = TARGET_TRANSFER_DOWNLOAD,
skip_all,
fields(tid = %self.id(), work = tracing::field::Empty),
)]
pub(crate) async fn execute(&self, work: &mut IoRequest) -> WorkOutcome {
let data = work.data_mut::<DownloadWork>();
tracing::Span::current().record("work", data.kind());
match data {
DownloadWork::Discovery => self.execute_discovery().await,
DownloadWork::GetObjectRange {
range,
slot,
etag,
digest_plan,
} => {
self.execute_get_range(
range.clone(),
slot.take().expect("slot already consumed"),
etag.clone(),
*digest_plan,
)
.await
}
DownloadWork::DrainResident => self.execute_drain_resident(),
}
}
fn execute_drain_resident(&self) -> WorkOutcome {
if !self.inner.ctx.is_active() {
return WorkOutcome::Cancelled;
}
let flushed = self.inner.writer.flush_resident();
self.record_disk_write(bytes_drained(&flushed));
let mut work = self.inner.state.lock().unwrap();
if let DownloadState::Transferring {
drains_in_flight, ..
} = &mut *work
{
*drains_in_flight -= 1;
}
let drained = match flushed {
Ok(drained) => drained,
Err(e) => {
return self.fail(work, error::Error::new(error::ErrorKind::IOError, e.source))
}
};
if let DownloadState::Transferring { gate, .. } = &mut *work {
gate.release(drained.parts);
}
let snapshot = self.snapshot(&work);
let completion = work.try_claim_completion();
drop(work);
self.inner
.observability
.record_memory_relief_completed(drained.parts);
self.inner.observability.observe_event(
self.inner.ctx.id,
DownloadEvent::MemoryReliefCompleted,
snapshot,
);
if let Some(claim) = completion {
return self.finalize_completion(claim);
}
self.inner.ctx.try_wake();
WorkOutcome::Success { data: None }
}
async fn execute_discovery(&self) -> WorkOutcome {
let input = self.inner.request.as_ref();
let validation_enabled = self.validation_enabled(input);
let discovery = match discover_obj(self, input, validation_enabled).await {
Ok(d) => d,
Err(e) => {
let guard = self.inner.state.lock().unwrap();
return self.fail(guard, e);
}
};
let ObjectDiscovery {
remaining,
object_range_start,
object_meta,
initial_chunk,
chunk_meta,
effective_part_size,
validation_plan,
} = discovery;
let _ = self
.inner
.object_meta
.set(process_object_metadata(object_meta.clone()));
let object_checksum_metadata =
if input.range.is_none() && (validation_enabled || remaining.is_none()) {
Some(object_meta.clone())
} else {
None
};
let integrity = Box::new(DownloadIntegrity::new(
validation_plan,
object_checksum_metadata,
));
let digest_plan = integrity.range_digest_plan();
self.inner.discovery_notify.notify_waiters();
let etag: Option<Arc<str>> = object_meta.e_tag.as_deref().map(Arc::from);
let chunk_content_len = chunk_meta
.as_ref()
.and_then(|m| m.content_length)
.and_then(|length| u64::try_from(length).ok())
.unwrap_or(0);
let expected_download_len =
chunk_content_len + remaining.as_ref().map_or(0, |r| r.end() - r.start() + 1);
if let Err(error) = self
.inner
.writer
.prepare(object_range_start, expected_download_len)
{
let guard = self.inner.state.lock().unwrap();
return self.fail(
guard,
crate::error::Error::new(crate::error::ErrorKind::IOError, error),
);
}
self.inner.observability.destination_prepared();
let _ = self.inner.expected_download_len.set(expected_download_len);
self.inner.ctx.set_total_bytes(expected_download_len);
let initial_work = match (initial_chunk, chunk_meta) {
(Some(mut initial), Some(meta)) => {
let req_metrics = initial
.request_metrics
.take()
.expect("ranged discovery body carries its request measurement");
let mut slot = self.inner.writer.claim();
match self.reserve_discovery_chunk(initial.expected_len).await {
Ok(Some(reservation)) => {
slot.attach_reservation(reservation);
Some((initial, req_metrics, meta, slot))
}
Ok(None) => {
drop(slot);
return WorkOutcome::Cancelled;
}
Err(error) => {
drop(slot);
let guard = self.inner.state.lock().unwrap();
return self.fail(
guard,
crate::error::Error::new(crate::error::ErrorKind::RuntimeError, error),
);
}
}
}
(None, _) => None,
(Some(_), None) => {
panic!("invalid discovery state: initial_chunk present without chunk_meta")
}
};
let has_initial_work = initial_work.is_some();
let all_ranges_issued = remaining.is_none();
let (discovery_snapshot, completion) = {
let initial = u64::from(initial_work.is_some());
let mut work = self.inner.state.lock().unwrap();
*work = DownloadState::Transferring {
remaining,
ranges_in_flight: initial as usize,
drains_in_flight: 0,
etag: etag.clone(),
part_size: effective_part_size,
gate: super::context::OccupancyGate::with_issued(initial),
pending: None,
integrity,
};
let snapshot = self.snapshot(&work);
let completion = if self.inner.ctx.is_active() {
work.try_claim_completion()
} else {
None
};
(snapshot, completion)
};
if has_initial_work {
self.inner.observability.record_range_scheduled();
}
self.inner.observability.observe_event(
self.inner.ctx.id,
DownloadEvent::DiscoveryCompleted,
discovery_snapshot,
);
if all_ranges_issued {
self.inner.observability.observe_event(
self.inner.ctx.id,
DownloadEvent::AllRangesIssued,
discovery_snapshot,
);
}
if let Some(claim) = completion {
return self.finalize_completion(claim);
}
self.inner.ctx.try_wake();
match initial_work {
Some((initial, request, chunk_meta, slot)) => {
self.execute_read_discovery_body(
initial,
request,
slot,
chunk_meta,
etag,
digest_plan,
)
.await
}
None => WorkOutcome::Success { data: None },
}
}
async fn execute_read_discovery_body(
&self,
initial: InitialChunk,
mut req_metrics: DownloadRequestMeasurement,
slot: BodySlot,
chunk_meta: ChunkMetadata,
etag: Option<Arc<str>>,
digest_plan: RangeDigestPlan,
) -> WorkOutcome {
let InitialChunk {
body,
checksum,
expected_len,
request_metrics: _,
} = initial;
req_metrics.resume();
let seq = slot.seq();
let input = self.inner.request.as_ref();
let reissue_range = chunk_meta
.content_range
.as_deref()
.and_then(crate::http::header::parse_content_range);
let mut initial = Some((body, checksum));
let recv_latencies = &self.inner.ctx.handle.telemetry.recv_latencies;
let reservation = slot.reservation();
let retry_classify = crate::retry::classify_body_retry;
let result = crate::retry::retry(req_metrics.metrics_mut(), retry_classify, |allow_hedge| {
let pre_issued = initial.take();
let etag = etag.clone();
let ctx = self.inner.ctx.clone();
let reissue_range = reissue_range.clone();
let mut builder =
copy_fields_to_get_object_request(input, ctx.s3_client().get_object());
if let Some(r) = reissue_range.as_ref() {
builder = builder.set_range(Some(format!("bytes={}-{}", r.start(), r.end())));
}
if let Some(etag) = etag.as_ref() {
builder = builder.if_match(etag.as_ref());
}
let checksum = ChecksumCapture::new();
let req = builder
.customize()
.interceptor(Capture::new().with(&checksum))
.config_override(ctx.download_get_override(input.bucket()));
async move {
let (body, checksum) = match pre_issued {
Some(initial) => initial,
None => {
if reissue_range.is_none() {
return Err(crate::retry::GuardError::Inner(
crate::error::Error::new(
crate::error::ErrorKind::RuntimeError,
"cannot re-issue discovery chunk: response carried no content-range",
),
));
}
let body = recv_latencies
.guarded(allow_hedge, async {
req.send()
.await
.map(|resp| resp.body)
.map_err(error::service_error)
})
.await?;
(body, checksum)
}
};
collect_response_body(
&ctx.handle.buffer_pool,
body,
&checksum,
reservation,
expected_len,
|| ctx.is_active(),
)
.await
.map(|segmented| (segmented, checksum))
.map_err(crate::retry::GuardError::Inner)
}
})
.instrument(tracing::trace_span!(
target: crate::telemetry::TARGET_TRANSFER_DOWNLOAD,
"download-part",
tid = %self.id()
))
.await;
let _ = req_metrics.finish();
let (segmented, checksum) = match result {
Ok(val) => val,
Err(e) => {
let guard = self.inner.state.lock().unwrap();
return self.fail(guard, e.with_chunk(ChunkRef::new(seq, None)));
}
};
bail_if_terminal!(self);
let offset = reissue_range
.as_ref()
.map(|range| *range.start())
.unwrap_or(0);
let completed =
match RangeCompletion::capture(offset, &segmented, checksum.try_outcome(), digest_plan)
{
Ok(completed) => completed,
Err(error) => return self.fail_range(ChunkRef::new(seq, None), error),
};
let bytes_received = completed.range.end - completed.range.start;
let chunk = ChunkOutput {
seq,
offset,
data: segmented,
metadata: chunk_meta,
};
let mut freed = 0u64;
if slot.fill(chunk) == FillOutcome::DrainReady {
let drain = self.inner.writer.drain(DrainMode::Batched);
self.record_disk_write(bytes_drained(&drain));
match drain {
Ok(drained) => freed = drained.parts,
Err(e) => {
let guard = self.inner.state.lock().unwrap();
return self.fail(
guard,
error::Error::new(error::ErrorKind::IOError, e.source),
);
}
}
}
self.inner.ctx.record_io(&crate::metrics::IoSample {
network_rx: bytes_received,
..Default::default()
});
if let Some(claim) = self.decrement_in_flight(freed, Some(completed)) {
return self.finalize_completion(claim);
}
WorkOutcome::Success { data: None }
}
async fn execute_get_range(
&self,
range: std::ops::RangeInclusive<u64>,
slot: BodySlot,
etag: Option<Arc<str>>,
digest_plan: RangeDigestPlan,
) -> WorkOutcome {
let seq = slot.seq();
let input = self.inner.request.as_ref();
let range_header = format!("bytes={}-{}", range.start(), range.end());
let expected_len = match range
.end()
.checked_sub(*range.start())
.and_then(|len| len.checked_add(1))
.and_then(|len| usize::try_from(len).ok())
{
Some(len) if len != 0 => len,
_ => {
return self.fail_range(
ChunkRef::new(seq, Some(*range.start()..=*range.end())),
error::Error::new(
error::ErrorKind::RuntimeError,
"download range length exceeds platform representation",
),
)
}
};
let reservation = slot.reservation();
let recv_latencies = &self.inner.ctx.handle.telemetry.recv_latencies;
let mut req_metrics = self.start_request(DownloadRequestKind::Range);
let retry_classify = crate::retry::classify_body_retry;
let object_len = self
.inner
.object_meta
.get()
.map(ObjectMetadata::total_object_size);
let result =
crate::retry::retry(req_metrics.metrics_mut(), retry_classify, |allow_hedge| {
let rh = range_header.clone();
let etag = etag.clone();
let ctx = self.inner.ctx.clone();
let mut builder =
copy_fields_to_get_object_request(input, ctx.s3_client().get_object());
builder = builder.set_range(Some(rh.clone()));
if let Some(etag) = etag.as_ref() {
builder = builder.if_match(etag.as_ref());
}
let checksum = ChecksumCapture::new();
let req = builder
.customize()
.interceptor(Capture::new().with(&checksum))
.config_override(ctx.download_get_override(input.bucket()));
async move {
let rh_validate = rh.clone();
let resp = recv_latencies
.guarded(allow_hedge, async move {
let resp = req.send().await.map_err(error::service_error)?;
validate_content_range(
&rh_validate,
resp.content_range(),
resp.content_length(),
object_len,
)
.map_err(|message| {
error::invalid_service_response("GetObject", &resp, message)
})?;
Ok::<_, crate::error::Error>(resp)
})
.await?;
let chunk_meta = crate::sdk_v1::chunk_metadata_from_get_object(&resp);
let segmented = collect_response_body(
&ctx.handle.buffer_pool,
resp.body,
&checksum,
reservation,
expected_len,
|| ctx.is_active(),
)
.await
.map_err(crate::retry::GuardError::Inner)?;
Ok::<_, crate::retry::GuardError<crate::error::Error>>((
chunk_meta, segmented, checksum,
))
}
})
.instrument(tracing::trace_span!(
target: crate::telemetry::TARGET_TRANSFER_DOWNLOAD,
"download-part-reissue",
tid = %self.id()
))
.await;
let _ = req_metrics.finish();
let (chunk_meta, segmented, checksum) = match result {
Ok(val) => val,
Err(e) => {
return self.fail_range(ChunkRef::new(seq, Some(*range.start()..=*range.end())), e)
}
};
bail_if_terminal!(self);
let completed = match RangeCompletion::capture(
*range.start(),
&segmented,
checksum.try_outcome(),
digest_plan,
) {
Ok(completed) => completed,
Err(error) => return self.fail_range(ChunkRef::new(seq, Some(range.clone())), error),
};
let bytes_received = completed.range.end - completed.range.start;
let chunk = ChunkOutput {
seq,
offset: *range.start(),
data: segmented,
metadata: chunk_meta,
};
let mut freed = 0u64;
if slot.fill(chunk) == FillOutcome::DrainReady {
let drain = self.inner.writer.drain(DrainMode::Batched);
self.record_disk_write(bytes_drained(&drain));
match drain {
Ok(drained) => freed = drained.parts,
Err(e) => {
let guard = self.inner.state.lock().unwrap();
return self.fail(
guard,
error::Error::new(error::ErrorKind::IOError, e.source),
);
}
}
}
self.inner.ctx.record_io(&crate::metrics::IoSample {
network_rx: bytes_received,
..Default::default()
});
if let Some(claim) = self.decrement_in_flight(freed, Some(completed)) {
return self.finalize_completion(claim);
}
tracing::trace!(
target: crate::telemetry::TARGET_TRANSFER_DOWNLOAD,
seq,
offset = *range.start(),
"chunk downloaded",
);
WorkOutcome::Success { data: None }
}
fn fail_range(&self, location: ChunkRef, e: Error) -> WorkOutcome {
let guard = self.inner.state.lock().unwrap();
self.fail(guard, e.with_chunk(location))
}
fn decrement_in_flight(
&self,
freed: u64,
completed: Option<RangeCompletion>,
) -> Option<CompletionClaim> {
let (completion, snapshot) = {
let mut work = self.inner.state.lock().unwrap();
match &mut *work {
DownloadState::Transferring {
ranges_in_flight,
gate,
remaining,
pending,
integrity,
..
} => {
if let Some(completed) = completed {
integrity.record(completed);
}
*ranges_in_flight = ranges_in_flight.saturating_sub(1);
gate.release(freed);
let snapshot = transferring_snapshot(
remaining.as_ref(),
*ranges_in_flight,
gate,
self.inner.read_ahead.window(),
pending.is_some(),
);
(work.try_claim_completion(), Some(snapshot))
}
_ => (None, None),
}
};
if let Some(snapshot) = snapshot {
self.inner.observability.record_range_completed(freed);
self.inner.observability.observe_event(
self.inner.ctx.id,
DownloadEvent::RangeCompleted,
snapshot,
);
}
if completion.is_none() {
self.inner.ctx.try_wake();
}
completion
}
fn finalize_completion(&self, claim: CompletionClaim) -> WorkOutcome {
let integrity_checks = match claim.finish_integrity() {
Ok(checks) => checks,
Err(error) => {
let guard = self.inner.state.lock().unwrap();
return self.fail(guard, error);
}
};
let expected_len = *self
.inner
.expected_download_len
.get()
.expect("completed download must have a discovered length");
let finalization = self.finalize_destination(expected_len);
if let Err(e) = finalization {
let guard = self.inner.state.lock().unwrap();
return self.fail(guard, error::Error::new(error::ErrorKind::IOError, e));
}
let _ = self.inner.integrity_checks.set(integrity_checks);
let state_snapshot = {
let state = self.inner.state.lock().expect("lock poisoned");
self.snapshot(&state)
};
if self.inner.writer.has_sink() {
self.inner.observability.observe_event(
self.inner.ctx.id,
DownloadEvent::DestinationFinalized,
state_snapshot,
);
}
self.inner.ctx.set_completed();
self.inner.writer.notify_consumer();
self.report_terminal(state_snapshot);
self.inner.ctx.signal_terminal();
WorkOutcome::Success { data: None }
}
fn fail(
&self,
mut guard: std::sync::MutexGuard<'_, DownloadState>,
error: Error,
) -> WorkOutcome {
let description = DisplayErrorContext(&error).to_string();
tracing::debug!(
target: crate::telemetry::TARGET_TRANSFER_DOWNLOAD,
error = %description,
"download failed",
);
let classification = crate::scheduler::classify_error(&error);
if !self.inner.ctx.set_failed(error)
&& self.inner.ctx.transfer_status() == crate::types::TransferStatus::Completed
{
debug_assert!(
false,
"download failed after it had completed: {description}"
);
tracing::error!(
target: crate::telemetry::TARGET_TRANSFER_DOWNLOAD,
tid = %self.inner.ctx.id,
error = %description,
"download failed after it had completed; the failure is not reported to the caller",
);
}
let snapshot = self.snapshot(&guard);
let pending = guard.enter_terminal();
drop(guard); drop(pending);
self.inner.discovery_notify.notify_waiters();
self.run_terminal_drain();
self.inner.writer.notify_consumer();
self.report_terminal(snapshot);
self.inner.ctx.signal_terminal();
WorkOutcome::Failed { classification }
}
fn record_disk_write(&self, bytes: u64) {
if bytes > 0 {
self.inner.ctx.record_io(&crate::metrics::IoSample {
disk_write: bytes,
..Default::default()
});
}
}
fn run_terminal_drain(&self) {
let drain = self.inner.writer.terminal_drain();
self.record_disk_write(bytes_drained(&drain));
self.inner
.observability
.terminal_drain_completed(&drain.map(|drained| drained.parts).map_err(|e| e.source));
}
fn finalize_destination(&self, expected_len: u64) -> Result<(), std::io::Error> {
let finalization = self.inner.writer.finalize(expected_len);
self.record_disk_write(bytes_drained(&finalization));
let finalization = finalization
.map(|drained| drained.parts)
.map_err(|e| e.source);
self.inner
.observability
.destination_finalized(&finalization);
finalization.map(|_| ())
}
}
impl Transfer for DownloadTransfer {
fn ctx(&self) -> &TransferContext {
DownloadTransfer::ctx(self)
}
fn poll_work(&self) -> PollWork {
DownloadTransfer::poll_work(self)
}
fn execute<'a>(
&'a self,
work: &'a mut IoRequest,
) -> Pin<Box<dyn Future<Output = WorkOutcome> + Send + 'a>> {
Box::pin(DownloadTransfer::execute(self, work))
}
fn on_terminal(&self) {
let (pending, snapshot) = {
let mut state = self
.inner
.state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
let snapshot = self.snapshot(&state);
(state.enter_terminal(), snapshot)
};
drop(pending);
self.inner.discovery_notify.notify_waiters();
self.run_terminal_drain();
self.inner.writer.notify_consumer();
self.report_terminal(snapshot);
}
}
fn bytes_drained(drain: &Result<Drained, DrainError>) -> u64 {
match drain {
Ok(drained) => drained.bytes,
Err(e) => e.drained.bytes,
}
}
fn snapshot_state(state: &DownloadState, read_ahead_window: u64) -> DownloadStateSnapshot {
match state {
DownloadState::PendingDiscovery => DownloadStateSnapshot::inactive(
DownloadExecutionState::PendingDiscovery,
read_ahead_window,
),
DownloadState::DiscoveryInFlight => DownloadStateSnapshot::inactive(
DownloadExecutionState::DiscoveryInFlight,
read_ahead_window,
),
DownloadState::Transferring {
remaining,
ranges_in_flight,
gate,
pending,
..
} => transferring_snapshot(
remaining.as_ref(),
*ranges_in_flight,
gate,
read_ahead_window,
pending.is_some(),
),
DownloadState::Terminal => {
DownloadStateSnapshot::inactive(DownloadExecutionState::Terminal, read_ahead_window)
}
}
}
fn transferring_snapshot(
remaining: Option<&std::ops::RangeInclusive<u64>>,
ranges_in_flight: usize,
gate: &super::context::OccupancyGate,
read_ahead_window: u64,
memory_claim_pending: bool,
) -> DownloadStateSnapshot {
DownloadStateSnapshot {
state: DownloadExecutionState::Transferring,
remaining_bytes: remaining.map(|range| {
range
.end()
.checked_sub(*range.start())
.and_then(|length| length.checked_add(1))
.expect("download state contains an invalid remaining range")
}),
ranges_in_flight,
ranges_issued: gate.issued(),
ranges_released: gate.released(),
resident_parts: gate.resident(),
read_ahead_window,
memory_claim_pending,
}
}
fn chunk_len(remaining: &std::ops::RangeInclusive<u64>, part_size: u64) -> usize {
let start = *remaining.start();
let end = *remaining.end();
let chunk_end = cmp::min(start + part_size - 1, end);
(chunk_end - start + 1) as usize
}
async fn collect_response_body(
pool: &BufferPool,
body: aws_sdk_s3::primitives::ByteStream,
checksum: &ChecksumCapture,
reservation: &Reservation,
expected_len: usize,
is_active: impl Fn() -> bool,
) -> Result<SegmentedBytes, Error> {
if expected_len == 0 {
return Err(response_length_error(0, 0));
}
let mut pooled = pool
.acquire(reservation, expected_len)
.map_err(pool_acquisition_error)?;
let mut bytes_received = 0usize;
let mut body_stream = body;
while let Some(result) = body_stream.next().await {
let data = result.map_err(|error| error::body_read_error(error, checksum.try_outcome()))?;
let remaining = expected_len
.checked_sub(bytes_received)
.ok_or_else(|| response_length_error(expected_len, bytes_received))?;
if data.len() > remaining {
return Err(response_length_error(
expected_len,
bytes_received.saturating_add(data.len()),
));
}
if !data.is_empty() {
debug_assert!(pooled.remaining_mut() >= data.len());
pooled.put_slice(&data);
bytes_received += data.len();
}
if !is_active() {
return Err(Error::new(
error::ErrorKind::OperationCancelled,
"transfer cancelled during body read",
));
}
}
if bytes_received != expected_len {
return Err(response_length_error(expected_len, bytes_received));
}
Ok(pooled.freeze())
}
fn response_length_error(expected: usize, received: usize) -> Error {
Error::new(
error::ErrorKind::IOError,
format!("response body length mismatch: expected {expected} bytes, received {received}"),
)
}
fn pool_acquisition_error(source: AcquireError) -> Error {
Error::new(error::ErrorKind::RuntimeError, source)
}
fn parse_byte_range(s: &str) -> Option<(u64, u64)> {
let s = s
.strip_prefix("bytes=")
.or_else(|| s.strip_prefix("bytes "))
.unwrap_or(s);
let range_part = s.split('/').next()?;
let (start_str, end_str) = range_part.split_once('-')?;
let start: u64 = start_str.trim().parse().ok()?;
let end: u64 = end_str.trim().parse().ok()?;
(start <= end).then_some((start, end))
}
fn validate_content_range(
requested_range: &str,
response_content_range: Option<&str>,
response_content_length: Option<i64>,
object_len: Option<u64>,
) -> Result<(), String> {
let requested = parse_byte_range(requested_range);
let response = response_content_range.and_then(parse_byte_range);
let whole_object = |len: u64| len.checked_sub(1).map(|end| (0, end));
match (requested, response) {
(Some(req), Some(resp)) if req == resp => Ok(()),
(Some(req), None)
if response_content_range.is_none()
&& object_len.and_then(whole_object) == Some(req)
&& response_content_length.and_then(|len| u64::try_from(len).ok())
== object_len =>
{
Ok(())
}
_ => Err(format!(
"content range mismatch: requested {}, response {:?}",
requested_range, response_content_range
)),
}
}
fn process_object_metadata(mut meta: ObjectMetadata) -> ObjectMetadata {
let composite = meta.checksum_type == Some(crate::model::ChecksumType::Composite);
if composite || !meta.covers_whole_object() {
meta.checksum_crc32 = None;
meta.checksum_crc32_c = None;
meta.checksum_crc64_nvme = None;
meta.checksum_md5 = None;
meta.checksum_sha1 = None;
meta.checksum_sha256 = None;
meta.checksum_sha512 = None;
meta.checksum_xxhash64 = None;
meta.checksum_xxhash3 = None;
meta.checksum_xxhash128 = None;
}
meta
}
#[cfg(test)]
mod tests {
use crate::types::ByteSize;
use std::future::Future;
use std::pin::Pin;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::task::{Context, Poll, Waker};
use bytes::{Buf, Bytes};
use http_body_1x::{Body as HttpBody, Frame, SizeHint};
use super::*;
use crate::model::ChecksumType;
use crate::operation::download::sink::FileSinkFactory;
use crate::operation::download::test_util::fixtures::{
assert_discovery_succeeds, assert_first_range_succeeds, crc32_object_client,
disk_test_handle, disk_transfer, execute, finalize_started, head_rule,
object_client_failing_at, relief_scenario, spawn_relief,
};
use crate::operation::download::DownloadInput;
use crate::scheduler::test_util::{assert_done, assert_pending, assert_ready};
use crate::transfer::TransferContext;
use crate::transfer::WorkOutcome;
use crate::types::BucketType;
use aws_sdk_s3::operation::get_object::GetObjectError;
use aws_sdk_s3::operation::get_object::GetObjectOutput;
use aws_sdk_s3::primitives::ByteStream;
use aws_smithy_mocks::{mock, mock_client, RuleMode};
use aws_smithy_types::error::metadata::ErrorMetadata;
const MB: u64 = 1024 * 1024;
#[test]
fn download_state_snapshot_classifies_execution_and_occupancy() {
assert_eq!(
snapshot_state(&DownloadState::PendingDiscovery, 4),
DownloadStateSnapshot::inactive(DownloadExecutionState::PendingDiscovery, 4)
);
assert_eq!(
snapshot_state(&DownloadState::DiscoveryInFlight, 4),
DownloadStateSnapshot::inactive(DownloadExecutionState::DiscoveryInFlight, 4)
);
assert_eq!(
snapshot_state(&DownloadState::Terminal, 4),
DownloadStateSnapshot::inactive(DownloadExecutionState::Terminal, 4)
);
let mut gate = super::super::context::OccupancyGate::with_issued(3);
gate.release(1);
let transferring = DownloadState::Transferring {
remaining: Some(8..=15),
ranges_in_flight: 2,
drains_in_flight: 0,
etag: None,
part_size: 8,
gate,
pending: None,
integrity: Box::default(),
};
assert_eq!(
snapshot_state(&transferring, 4),
DownloadStateSnapshot {
state: DownloadExecutionState::Transferring,
remaining_bytes: Some(8),
ranges_in_flight: 2,
ranges_issued: 3,
ranges_released: 1,
resident_parts: 2,
read_ahead_window: 4,
memory_claim_pending: false,
}
);
}
struct TestFrameBody {
frames: std::collections::VecDeque<Bytes>,
remaining: usize,
}
impl TestFrameBody {
fn new(frames: impl IntoIterator<Item = Bytes>) -> Self {
let frames: std::collections::VecDeque<_> = frames.into_iter().collect();
let remaining = frames.iter().map(Bytes::len).sum();
Self { frames, remaining }
}
fn into_byte_stream(self) -> aws_sdk_s3::primitives::ByteStream {
aws_sdk_s3::primitives::ByteStream::from_body_1_x(self)
}
}
impl HttpBody for TestFrameBody {
type Data = Bytes;
type Error = std::convert::Infallible;
fn poll_frame(
mut self: Pin<&mut Self>,
_context: &mut Context<'_>,
) -> Poll<Option<Result<Frame<Self::Data>, Self::Error>>> {
let Some(frame) = self.frames.pop_front() else {
return Poll::Ready(None);
};
self.remaining = self
.remaining
.checked_sub(frame.len())
.expect("test frame accounting underflow");
Poll::Ready(Some(Ok(Frame::data(frame))))
}
fn is_end_stream(&self) -> bool {
self.frames.is_empty()
}
fn size_hint(&self) -> SizeHint {
SizeHint::with_exact(self.remaining as u64)
}
}
struct CountedFrame {
bytes: Vec<u8>,
drops: Arc<AtomicUsize>,
}
impl AsRef<[u8]> for CountedFrame {
fn as_ref(&self) -> &[u8] {
&self.bytes
}
}
impl Drop for CountedFrame {
fn drop(&mut self) {
self.drops.fetch_add(1, Ordering::Relaxed);
}
}
fn test_pool() -> BufferPool {
crate::memory::BufferPool::builder()
.memory_budget(crate::config::MemoryBudgetConfig::Limit(ByteSize::new(
128 * 1024,
)))
.build()
.expect("response collector test pool")
}
fn collect_ready(
pool: &BufferPool,
body: aws_sdk_s3::primitives::ByteStream,
reservation: &Reservation,
expected_len: usize,
) -> Result<SegmentedBytes, Error> {
collect_ready_with(pool, body, reservation, expected_len, || true)
}
fn collect_ready_with(
pool: &BufferPool,
body: aws_sdk_s3::primitives::ByteStream,
reservation: &Reservation,
expected_len: usize,
is_active: impl Fn() -> bool,
) -> Result<SegmentedBytes, Error> {
let checksum = ChecksumCapture::new();
let mut future = std::pin::pin!(collect_response_body(
pool,
body,
&checksum,
reservation,
expected_len,
is_active,
));
let mut context = Context::from_waker(Waker::noop());
match future.as_mut().poll(&mut context) {
Poll::Ready(result) => result,
Poll::Pending => panic!("in-memory test body unexpectedly yielded Pending"),
}
}
#[test]
fn test_collection_acquires_response_once_and_releases_foreign_frames() {
const FRAME_LEN: usize = 9_000;
const EXPECTED_LEN: usize = FRAME_LEN * 3;
let pool = test_pool();
let reservation = pool
.try_reserve(EXPECTED_LEN)
.unwrap()
.expect("collector reservation");
let expected: Vec<u8> = (0..EXPECTED_LEN)
.map(|index| (index.wrapping_mul(31) % 251) as u8)
.collect();
let drops = Arc::new(AtomicUsize::new(0));
let first = Bytes::from_owner(CountedFrame {
bytes: expected[..FRAME_LEN].to_vec(),
drops: Arc::clone(&drops),
});
let body = TestFrameBody::new([
Bytes::new(),
first,
Bytes::copy_from_slice(&expected[FRAME_LEN..FRAME_LEN * 2]),
Bytes::copy_from_slice(&expected[FRAME_LEN * 2..]),
])
.into_byte_stream();
let acquisitions_before = pool.acquisition_attempts();
let mut output = collect_ready(&pool, body, &reservation, EXPECTED_LEN)
.expect("response fits its reserved envelope");
assert_eq!(
pool.acquisition_attempts() - acquisitions_before,
1,
"one response must perform one carrier acquisition"
);
assert_eq!(output.len(), EXPECTED_LEN);
let mut slices = [std::io::IoSlice::new(&[]); 4];
assert_eq!(
output.chunks_vectored(&mut slices),
1,
"adjacent carriers from one acquisition should form one segment"
);
assert_eq!(
drops.load(Ordering::Relaxed),
1,
"transport owner must drop after its frame is copied"
);
assert_ne!(pool.metrics().in_use_bytes(), 0);
assert_eq!(output.copy_to_bytes(EXPECTED_LEN).as_ref(), expected);
assert_eq!(pool.metrics().in_use_bytes(), 0);
}
#[test]
fn test_collection_rejects_zero_length_without_acquiring_storage() {
let pool = test_pool();
let reservation = pool
.try_reserve(pool.carrier_size())
.unwrap()
.expect("collector reservation");
let acquisitions_before = pool.acquisition_attempts();
let error = collect_ready(
&pool,
TestFrameBody::new([]).into_byte_stream(),
&reservation,
0,
)
.expect_err("zero-length collection unexpectedly succeeded");
assert_eq!(error.kind(), &error::ErrorKind::IOError);
assert_eq!(pool.acquisition_attempts(), acquisitions_before);
assert_eq!(pool.metrics().in_use_bytes(), 0);
}
#[test]
fn test_short_attempt_restores_reservation_authority_before_retry() {
const EXPECTED_LEN: usize = 20_000;
let pool = test_pool();
let reservation = pool
.try_reserve(EXPECTED_LEN)
.unwrap()
.expect("collector reservation");
let short = TestFrameBody::new([
Bytes::from(vec![0x11; 9_000]),
Bytes::from(vec![0x22; 9_000]),
])
.into_byte_stream();
let error = collect_ready(&pool, short, &reservation, EXPECTED_LEN)
.expect_err("short attempt unexpectedly succeeded");
assert_eq!(error.kind(), &error::ErrorKind::IOError);
assert_eq!(pool.metrics().in_use_bytes(), 0);
let expected: Vec<u8> = (0..EXPECTED_LEN)
.map(|index| (index.wrapping_mul(17) % 251) as u8)
.collect();
let retry = TestFrameBody::new([
Bytes::copy_from_slice(&expected[..7_000]),
Bytes::copy_from_slice(&expected[7_000..]),
])
.into_byte_stream();
let output = collect_ready(&pool, retry, &reservation, EXPECTED_LEN)
.expect("retry reacquires returned authority");
assert_eq!(
output.clone().copy_to_bytes(EXPECTED_LEN).as_ref(),
expected
);
reservation.close_acquisition();
assert_ne!(
pool.metrics().in_use_bytes(),
0,
"immutable output retains pooled owners after reservation close"
);
drop(output);
assert_eq!(pool.metrics().in_use_bytes(), 0);
}
#[test]
fn test_collection_rejects_same_carrier_length_overrun() {
const EXPECTED_LEN: usize = 8;
let pool = test_pool();
let reservation = pool
.try_reserve(EXPECTED_LEN)
.unwrap()
.expect("collector reservation");
let body = TestFrameBody::new([Bytes::from_static(b"123456789")]).into_byte_stream();
let error = collect_ready(&pool, body, &reservation, EXPECTED_LEN)
.expect_err("oversized attempt unexpectedly succeeded");
assert_eq!(error.kind(), &error::ErrorKind::IOError);
assert_eq!(pool.metrics().in_use_bytes(), 0);
}
#[test]
fn test_collection_observes_cancellation_after_an_empty_frame() {
let pool = test_pool();
let reservation = pool.try_reserve(4).unwrap().expect("collector reservation");
let body =
TestFrameBody::new([Bytes::new(), Bytes::from_static(b"data")]).into_byte_stream();
let error = collect_ready_with(&pool, body, &reservation, 4, || false)
.expect_err("cancelled attempt unexpectedly succeeded");
assert_eq!(error.kind(), &error::ErrorKind::OperationCancelled);
assert_eq!(pool.metrics().in_use_bytes(), 0);
}
#[test]
fn test_collection_rejects_reservation_envelope_exhaustion() {
const RESPONSE_LEN: usize = 128 * 1024;
let pool = test_pool();
let reservation = pool.try_reserve(1).unwrap().expect("one-carrier envelope");
let body = TestFrameBody::new([Bytes::from(vec![0; RESPONSE_LEN])]).into_byte_stream();
let error = collect_ready(&pool, body, &reservation, RESPONSE_LEN)
.expect_err("acquisition escaped its reservation envelope");
assert_eq!(error.kind(), &error::ErrorKind::RuntimeError);
assert_eq!(pool.metrics().in_use_bytes(), 0);
drop(
pool.acquire(&reservation, 1)
.expect("failed acquisition did not consume direct authority"),
);
assert_eq!(pool.metrics().in_use_bytes(), 0);
}
#[test]
fn object_metadata_clears_checksum_values_that_do_not_describe_the_object() {
let meta = |checksum_type, content_range: Option<&str>| {
let mut m = ObjectMetadata::default();
m.checksum_crc32 = Some("DUoRhQ==".to_string());
m.checksum_type = Some(checksum_type);
m.content_range = content_range.map(str::to_owned);
m
};
for range in [None, Some("bytes 0-99/100")] {
let m = process_object_metadata(meta(ChecksumType::FullObject, range));
assert_eq!(m.checksum_crc32(), Some("DUoRhQ=="), "{range:?}");
}
for range in ["bytes 0-49/100", "bytes 50-99/100"] {
let m = process_object_metadata(meta(ChecksumType::FullObject, Some(range)));
assert_eq!(m.checksum_crc32(), None, "{range}");
assert_eq!(m.checksum_type(), Some(&ChecksumType::FullObject));
}
let m = process_object_metadata(meta(ChecksumType::Composite, None));
assert_eq!(m.checksum_crc32(), None);
assert_eq!(m.checksum_type(), Some(&ChecksumType::Composite));
}
fn checksum_value_members(meta: &ObjectMetadata) -> Vec<String> {
format!("{meta:#?}")
.lines()
.filter_map(|line| line.trim().split_once(": "))
.map(|(name, _)| name)
.filter(|name| name.starts_with("checksum_") && *name != "checksum_type")
.map(str::to_owned)
.collect()
}
#[test]
fn object_metadata_clears_every_checksum_value_member() {
let mut meta = ObjectMetadata::default();
meta.checksum_crc32 = Some("v".to_owned());
meta.checksum_crc32_c = Some("v".to_owned());
meta.checksum_crc64_nvme = Some("v".to_owned());
meta.checksum_md5 = Some("v".to_owned());
meta.checksum_sha1 = Some("v".to_owned());
meta.checksum_sha256 = Some("v".to_owned());
meta.checksum_sha512 = Some("v".to_owned());
meta.checksum_xxhash64 = Some("v".to_owned());
meta.checksum_xxhash3 = Some("v".to_owned());
meta.checksum_xxhash128 = Some("v".to_owned());
meta.checksum_type = Some(ChecksumType::Composite);
let members = checksum_value_members(&meta);
assert!(
!members.is_empty(),
"no checksum members found in Debug output"
);
let populated = format!("{meta:#?}");
for member in &members {
assert!(
populated.contains(&format!("{member}: Some(")),
"`{member}` is not populated by this test; set it and clear it in process_object_metadata"
);
}
let cleared = format!("{:#?}", process_object_metadata(meta));
for member in &members {
assert!(
cleared.contains(&format!("{member}: None")),
"`{member}` was not cleared"
);
}
}
fn create_download(object_size: u64, part_size: u64) -> DownloadTransfer {
create_download_with_detail(object_size, part_size, 0)
}
fn create_download_with_detail(
object_size: u64,
part_size: u64,
detail: u64,
) -> DownloadTransfer {
let chunk = vec![0u8; part_size as usize];
let get_obj = mock!(aws_sdk_s3::Client::get_object).then_output(move || {
GetObjectOutput::builder()
.content_length(part_size as i64)
.content_range(format!("bytes 0-{}/{}", part_size - 1, object_size))
.e_tag("test-etag")
.body(ByteStream::from(chunk.clone()))
.build()
});
create_get_first_download_with_client_and_detail(
mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[get_obj]),
part_size,
detail,
Some(object_size),
)
}
fn create_get_first_download_with_client_and_detail(
client: aws_sdk_s3::Client,
part_size: u64,
detail: u64,
object_size: Option<u64>,
) -> DownloadTransfer {
let config = crate::Config::builder()
.sdk_client(client)
.part_size(crate::config::PartSize::Target(ByteSize::new(part_size)))
.diagnostics_for_test(crate::config::MemoryDiagnosticsConfig::default(), detail)
.build()
.expect("valid config");
let handle = crate::client::Handle::test_handle_tokio(config);
let input = DownloadInput::builder()
.bucket("test-bucket")
.key("test-key")
.set_range(object_size.map(|len| format!("bytes=0-{}", len - 1)))
.build()
.unwrap();
let (writer, _consumer) = crate::operation::download::body::new_recv_body();
let (ctx, _completion_rx) = TransferContext::new(handle);
DownloadTransfer::new(ctx, BucketType::Standard, input, writer)
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn validation_enabled_resolves_request_and_client_settings() {
use aws_sdk_s3::config::ResponseChecksumValidation::{WhenRequired, WhenSupported};
for (client_setting, unset_enabled) in [
(None, true),
(Some(WhenSupported), true),
(Some(WhenRequired), false),
] {
let client = mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[head_rule(0)], |conf| {
match client_setting {
Some(setting) => conf.response_checksum_validation(setting),
None => conf,
}
});
let transfer =
create_get_first_download_with_client_and_detail(client, 8 * MB, 0, None);
for (request_mode, expected) in [
(None, unset_enabled),
(Some(crate::model::ChecksumMode::Enabled), true),
] {
let input = DownloadInput::builder()
.bucket("test-bucket")
.key("test-key")
.set_checksum_mode(request_mode)
.build()
.unwrap();
assert_eq!(
transfer.validation_enabled(&input),
expected,
"client={client_setting:?}, request={:?}",
input.checksum_mode,
);
}
}
}
#[cfg_attr(miri, ignore)]
#[test]
fn test_initial_poll_returns_discovery() {
let transfer = create_download(24 * MB, 8 * MB);
let mut work = assert_ready(transfer.poll_work());
let data = work.data_mut::<DownloadWork>();
assert!(matches!(data, DownloadWork::Discovery));
}
#[cfg_attr(miri, ignore)]
#[test]
fn test_pending_while_discovery_in_flight() {
let transfer = create_download(24 * MB, 8 * MB);
let _work = assert_ready(transfer.poll_work());
assert_pending(transfer.poll_work());
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_generates_ranges_after_discovery() {
let transfer = create_download(24 * MB, 8 * MB);
assert_discovery_succeeds(&transfer).await;
assert_eq!(
transfer.ctx().metrics.request_metrics().requests,
1,
"discovery headers and its lazy response body are one request"
);
let mut work = assert_ready(transfer.poll_work());
let data = work.data_mut::<DownloadWork>();
assert!(matches!(data, DownloadWork::GetObjectRange { .. }));
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn diagnostic_levels_preserve_stream_download_outcome() {
for detail in 0..=2 {
let transfer = create_download_with_detail(8 * MB, 8 * MB, detail);
assert_discovery_succeeds(&transfer).await;
assert_eq!(
transfer.ctx().transfer_status(),
crate::types::TransferStatus::Completed
);
let summary = transfer.test_terminal_summary();
if detail == 0 {
assert!(summary.is_none());
continue;
}
let summary = summary.expect("summary diagnostics enabled");
assert_eq!(
summary.outcome,
crate::operation::download::observability::DownloadTerminalOutcome::Completed
);
assert_eq!(summary.destination, DownloadDestination::Stream);
assert_eq!(summary.metrics.network_rx, 8 * MB);
assert_eq!(summary.metrics.disk_write, 0);
assert_eq!(summary.requests.discovery_range.requests, 1);
assert_eq!(summary.requests.range.requests, 0);
assert_eq!(summary.request_total.requests, 1);
assert_eq!(summary.ranges_scheduled, 1);
assert_eq!(summary.ranges_completed, 1);
assert_eq!(
summary.last_active_snapshot.resident_parts, 1,
"terminal receive does not imply stream-consumer delivery"
);
assert!(!summary.destination_work.file_finalized);
}
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn empty_download_summary_records_discovery_without_ranges() {
let part_size = 8 * MB;
let expected_range = format!("bytes=0-{}", part_size - 1);
let ranged = mock!(aws_sdk_s3::Client::get_object)
.match_requests(move |request| request.range() == Some(expected_range.as_str()))
.then_error(|| {
GetObjectError::generic(ErrorMetadata::builder().code("InvalidRange").build())
});
let part = mock!(aws_sdk_s3::Client::get_object)
.match_requests(|request| request.part_number() == Some(1))
.then_output(|| GetObjectOutput::builder().content_length(0).build());
let client = mock_client!(
aws_sdk_s3,
RuleMode::Sequential,
&[&ranged, &part],
|conf| {
conf.response_checksum_validation(
aws_sdk_s3::config::ResponseChecksumValidation::WhenRequired,
)
}
);
let transfer = create_get_first_download_with_client_and_detail(client, part_size, 1, None);
assert_discovery_succeeds(&transfer).await;
assert_done(transfer.poll_work());
let summary = transfer
.test_terminal_summary()
.expect("summary diagnostics enabled");
assert_eq!(
summary.outcome,
crate::operation::download::observability::DownloadTerminalOutcome::Completed
);
assert_eq!(summary.metrics.total_bytes, Some(0));
assert_eq!(summary.metrics.network_rx, 0);
assert_eq!(summary.requests.discovery_range.requests, 1);
assert_eq!(summary.requests.discovery_part.requests, 1);
assert_eq!(summary.request_total.requests, 2);
assert_eq!(summary.ranges_scheduled, 0);
assert_eq!(summary.ranges_completed, 0);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn zero_byte_object_completes_from_discovery() {
use crate::operation::download::test_util::sink::{
Event, Op, ScriptedSinkFactory, WriteScript,
};
let part_size = 8 * MB;
let client = mock_client!(aws_sdk_s3, &[head_rule(0)]);
let script = Arc::new(WriteScript::default());
let (transfer, _consumer, _dir) = disk_transfer(
disk_test_handle(client, part_size),
&ScriptedSinkFactory(Arc::clone(&script)),
);
let mut discovery = assert_ready(transfer.poll_work());
let outcome = execute(&transfer, &mut discovery).await;
assert!(matches!(outcome, WorkOutcome::Success { .. }));
assert_eq!(
transfer.ctx().transfer_status(),
crate::types::TransferStatus::Completed
);
let finalize = Op::Finalize { len: 0 };
assert_eq!(
script.events(),
[Event::Started(finalize), Event::Finished(finalize, Ok(()))],
"discovery's execute finalized the destination"
);
assert_done(transfer.poll_work());
}
#[cfg_attr(miri, ignore)]
#[test]
fn on_terminal_tolerates_poisoned_state() {
let transfer = create_download_with_detail(24 * MB, 8 * MB, 1);
let _discovery = assert_ready(transfer.poll_work());
std::thread::scope(|scope| {
let poisoner = scope.spawn(|| {
let _guard = transfer.inner.state.lock().unwrap();
panic!("invalid discovery state");
});
assert!(poisoner.join().is_err());
});
assert!(
transfer.inner.state.lock().is_err(),
"state should be poisoned"
);
transfer.ctx().set_failed(error::Error::new(
error::ErrorKind::RuntimeError,
"worker panic during execute",
));
let cleanup =
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| transfer.on_terminal()));
assert!(
cleanup.is_ok(),
"on_terminal must tolerate a poisoned state"
);
let summary = transfer
.test_terminal_summary()
.expect("poisoned state should still emit a terminal summary");
assert_eq!(
summary.outcome,
crate::operation::download::observability::DownloadTerminalOutcome::Failed
);
}
#[cfg_attr(miri, ignore)]
#[test]
fn external_cancellation_reports_pending_discovery_once() {
let transfer = create_download_with_detail(24 * MB, 8 * MB, 1);
let _discovery = assert_ready(transfer.poll_work());
assert_pending(transfer.poll_work());
transfer.ctx().set_cancelled();
transfer.on_terminal();
transfer.ctx().signal_terminal();
transfer.on_terminal();
let summary = transfer
.test_terminal_summary()
.expect("cancellation summary");
assert_eq!(
summary.outcome,
crate::operation::download::observability::DownloadTerminalOutcome::Cancelled
);
assert_eq!(
summary
.pending
.category(crate::transfer::PendingCategory::InFlightWork)
.count,
1
);
assert_eq!(
summary.last_active_snapshot.state,
DownloadExecutionState::DiscoveryInFlight
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_seq_starts_at_one_with_initial_chunk() {
let transfer = create_download(24 * MB, 8 * MB);
assert_discovery_succeeds(&transfer).await;
let mut work = assert_ready(transfer.poll_work());
let data = work.data_mut::<DownloadWork>();
match data {
DownloadWork::GetObjectRange { slot, .. } => {
assert_eq!(
slot.as_ref().unwrap().seq(),
1,
"seq should start at 1 when initial chunk claims seq=0"
);
}
_ => panic!("expected GetObjectRange"),
}
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_seq_starts_at_zero_without_initial_chunk() {
let head_obj = mock!(aws_sdk_s3::Client::head_object).then_output(|| {
aws_sdk_s3::operation::head_object::HeadObjectOutput::builder()
.content_length(24 * MB as i64)
.content_range(format!("bytes 0-{}/{}", 24 * MB - 1, 24 * MB))
.e_tag("test-etag")
.build()
});
let get_obj = mock!(aws_sdk_s3::Client::get_object).then_output(|| {
aws_sdk_s3::operation::get_object::GetObjectOutput::builder()
.content_length(8 * MB as i64)
.content_range(format!("bytes 0-{}/{}", 8 * MB - 1, 24 * MB))
.e_tag("test-etag")
.body(ByteStream::from(vec![0u8; 8 * MB as usize]))
.build()
});
let client = mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[head_obj, get_obj]);
let config = crate::Config::builder()
.sdk_client(client)
.part_size(crate::config::PartSize::Target(ByteSize::new(8 * MB)))
.build()
.expect("valid config");
let handle = crate::client::Handle::test_handle_tokio(config);
let input = DownloadInput::builder()
.bucket("test-bucket")
.key("test-key")
.range("bytes=0-")
.build()
.unwrap();
let (writer, _consumer) = crate::operation::download::body::new_recv_body();
let (ctx, _completion_rx) = TransferContext::new(handle);
let transfer = DownloadTransfer::new(ctx, BucketType::Standard, input, writer);
assert_discovery_succeeds(&transfer).await;
let mut work = assert_ready(transfer.poll_work());
let data = work.data_mut::<DownloadWork>();
match data {
DownloadWork::GetObjectRange { slot, .. } => {
assert_eq!(
slot.as_ref().unwrap().seq(),
0,
"seq should start at 0 when no initial chunk"
);
}
_ => panic!("expected GetObjectRange"),
}
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_seq_increments_sequentially() {
let transfer = create_download(32 * MB, 8 * MB);
assert_discovery_succeeds(&transfer).await;
let mut seqs = Vec::new();
while let PollWork::Ready { io: mut w, .. } = transfer.poll_work() {
let data = w.data_mut::<DownloadWork>();
if let DownloadWork::GetObjectRange { slot, .. } = data {
seqs.push(slot.as_ref().unwrap().seq());
}
}
assert_eq!(seqs.len(), 3, "expected multiple ranges");
for i in 1..seqs.len() {
assert_eq!(seqs[i], seqs[i - 1] + 1, "seqs should be sequential");
}
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_pending_when_range_in_flight() {
let transfer = create_download(12 * MB, 8 * MB);
assert_discovery_succeeds(&transfer).await;
let _range = assert_ready(transfer.poll_work());
assert_pending(transfer.poll_work());
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_done_when_all_complete() {
let transfer = create_download(12 * MB, 8 * MB);
assert_discovery_succeeds(&transfer).await;
let mut range = assert_ready(transfer.poll_work());
execute(&transfer, &mut range).await;
assert_done(transfer.poll_work());
assert_eq!(transfer.ctx().metrics.request_metrics().requests, 2);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_out_of_order_completion() {
let transfer = create_download(24 * MB, 8 * MB);
assert_discovery_succeeds(&transfer).await;
let mut range1 = assert_ready(transfer.poll_work()); let mut range2 = assert_ready(transfer.poll_work());
execute(&transfer, &mut range2).await;
execute(&transfer, &mut range1).await;
assert_done(transfer.poll_work());
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_failure_transitions_to_failed() {
let _logs = show_test_logs();
let transfer = FailureConfig::new(24 * MB, 8 * MB)
.fail(1)
.detail(1)
.build();
assert_discovery_succeeds(&transfer).await;
let mut range = assert_ready(transfer.poll_work());
let outcome = execute(&transfer, &mut range).await;
assert!(matches!(outcome, WorkOutcome::Failed { .. }));
assert!(transfer.ctx().is_failed());
let summary = transfer
.test_terminal_summary()
.expect("failure summary diagnostics enabled");
assert_eq!(
summary.outcome,
crate::operation::download::observability::DownloadTerminalOutcome::Failed
);
assert_eq!(summary.requests.discovery_range.requests, 1);
assert_eq!(summary.requests.range.requests, 1);
assert_eq!(summary.requests.range.retry_reissues, 0);
assert_eq!(summary.requests.range.retry_exhaustions, 0);
assert_eq!(summary.ranges_scheduled, 2);
assert_eq!(summary.ranges_completed, 1);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn multi_range_summary_separates_discovery_and_range_requests() {
let transfer = FailureConfig::new(12 * MB, 8 * MB).detail(1).build();
assert_discovery_succeeds(&transfer).await;
let mut range = assert_ready(transfer.poll_work());
let outcome = execute(&transfer, &mut range).await;
assert!(matches!(outcome, WorkOutcome::Success { .. }));
let summary = transfer
.test_terminal_summary()
.expect("summary diagnostics enabled");
assert_eq!(summary.requests.discovery_range.requests, 1);
assert_eq!(summary.requests.range.requests, 1);
assert_eq!(summary.request_total.requests, 2);
assert_eq!(summary.ranges_scheduled, 2);
assert_eq!(summary.ranges_completed, 2);
assert_eq!(summary.metrics.network_rx, 12 * MB);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn discovery_body_reissue_stays_with_discovery_request_metrics() {
let part_size = 8 * MB;
let calls = Arc::new(AtomicUsize::new(0));
let get_obj = mock!(aws_sdk_s3::Client::get_object).then_compute_response({
let calls = Arc::clone(&calls);
move |_| {
let call = calls.fetch_add(1, Ordering::SeqCst);
let body_len = if call == 0 { part_size / 2 } else { part_size };
MockResponse::Output(
GetObjectOutput::builder()
.content_length(part_size as i64)
.content_range(format!("bytes 0-{}/{}", part_size - 1, part_size))
.e_tag("test-etag")
.body(ByteStream::from(vec![0u8; body_len as usize]))
.build(),
)
}
});
let client = mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[get_obj], |conf| {
conf.retry_config(aws_sdk_s3::config::retry::RetryConfig::disabled())
});
let transfer =
create_get_first_download_with_client_and_detail(client, part_size, 1, Some(part_size));
assert_discovery_succeeds(&transfer).await;
assert_eq!(calls.load(Ordering::SeqCst), 2);
let summary = transfer
.test_terminal_summary()
.expect("summary diagnostics enabled");
assert_eq!(summary.requests.discovery_range.requests, 1);
assert_eq!(summary.requests.discovery_range.retry_reissues, 1);
assert_eq!(summary.request_total.requests, 1);
assert_eq!(summary.request_total.retry_reissues, 1);
assert_eq!(summary.requests.range.requests, 0);
}
#[cfg_attr(miri, ignore)]
#[tokio::test(start_paused = true)]
async fn discovery_memory_wait_is_excluded_from_request_elapsed() {
let part_size = 8 * MB;
let memory_wait = std::time::Duration::from_secs(10);
let (transfer, _consumer) =
create_download_for_gate_with_capacity(part_size, part_size, Some(part_size as usize));
let pool = transfer.ctx().handle.buffer_pool.clone();
let blocker = pool
.try_reserve(part_size as usize)
.unwrap()
.expect("test blocker");
let mut work = assert_ready(transfer.poll_work());
let executing = transfer.clone();
let task = tokio::spawn(async move { execute(&executing, &mut work).await });
tokio::time::timeout(std::time::Duration::from_secs(5), async {
while pool.metrics().waiting_requests() != 1 {
tokio::task::yield_now().await;
}
})
.await
.expect("discovery reservation should enter the memory FIFO");
tokio::time::sleep(memory_wait).await;
drop(blocker);
assert!(matches!(task.await.unwrap(), WorkOutcome::Success { .. }));
let requests = transfer.ctx().metrics.request_metrics();
assert_eq!(requests.requests, 1);
assert!(
requests.max_elapsed < memory_wait / 10,
"discovery request elapsed {:?} includes the {memory_wait:?} memory wait",
requests.max_elapsed,
);
}
#[derive(Debug)]
struct DelayedFirstPartConnector {
object_size: u64,
stored_part_size: u64,
part_delay: std::time::Duration,
}
impl aws_smithy_runtime_api::client::http::HttpConnector for DelayedFirstPartConnector {
fn call(
&self,
request: aws_smithy_runtime_api::client::orchestrator::HttpRequest,
) -> aws_smithy_runtime_api::client::http::HttpConnectorFuture {
use aws_smithy_runtime_api::client::http::HttpConnectorFuture;
use aws_smithy_runtime_api::client::orchestrator::HttpResponse;
if request.method() == "HEAD" {
let mut response = HttpResponse::new(
200.try_into().unwrap(),
aws_smithy_types::body::SdkBody::empty(),
);
response
.headers_mut()
.insert("content-length", self.object_size.to_string());
response.headers_mut().insert("etag", "\"abc-2\"");
response
.headers_mut()
.insert("x-amz-checksum-crc32", "AAAAAA==-2");
response
.headers_mut()
.insert("x-amz-checksum-type", "COMPOSITE");
return HttpConnectorFuture::ready(Ok(response));
}
let is_part_request = request.uri().contains("partNumber=1");
let (start, end) = if is_part_request {
(0, self.stored_part_size - 1)
} else {
request
.headers()
.get("range")
.and_then(parse_byte_range)
.unwrap_or_else(|| panic!("unexpected request: {}", request.uri()))
};
let len = end - start + 1;
let mut response = HttpResponse::new(
206.try_into().unwrap(),
aws_smithy_types::body::SdkBody::from(vec![0u8; len as usize]),
);
let headers = response.headers_mut();
headers.insert("Content-Length", len.to_string());
headers.insert(
"Content-Range",
format!("bytes {start}-{end}/{}", self.object_size),
);
headers.insert("ETag", "\"abc-2\"");
if is_part_request {
let delay = self.part_delay;
HttpConnectorFuture::new(async move {
tokio::time::sleep(delay).await;
Ok(response)
})
} else {
HttpConnectorFuture::ready(Ok(response))
}
}
}
#[cfg_attr(miri, ignore)]
#[tokio::test(start_paused = true)]
async fn layout_get_latency_is_excluded_from_head_discovery_elapsed() {
let stored_part_size = 8 * MB;
let part_delay = std::time::Duration::from_secs(10);
let connector = aws_smithy_runtime_api::client::http::SharedHttpConnector::new(
DelayedFirstPartConnector {
object_size: 2 * stored_part_size,
stored_part_size,
part_delay,
},
);
let http_client =
aws_smithy_runtime_api::client::http::http_client_fn(move |_, _| connector.clone());
let client = aws_sdk_s3::Client::from_conf(
aws_sdk_s3::config::Config::builder()
.http_client(http_client)
.region(aws_sdk_s3::config::Region::new("us-west-2"))
.with_test_defaults()
.build(),
);
let config = crate::Config::builder()
.sdk_client(client)
.diagnostics_for_test(crate::config::MemoryDiagnosticsConfig::default(), 1)
.build()
.expect("valid config");
let handle = crate::client::Handle::test_handle_tokio(config);
assert!(!handle.user_set_part_size());
let input = DownloadInput::builder()
.bucket("test-bucket")
.key("test-key")
.build()
.unwrap();
let (writer, _consumer) = crate::operation::download::body::new_recv_body();
let (ctx, _completion_rx) = TransferContext::new(handle);
let transfer = DownloadTransfer::new(ctx, BucketType::Standard, input, writer);
assert_discovery_succeeds(&transfer).await;
let mut range = assert_ready(transfer.poll_work());
assert!(matches!(
execute(&transfer, &mut range).await,
WorkOutcome::Success { .. }
));
let summary = transfer
.test_terminal_summary()
.expect("summary diagnostics enabled");
assert_eq!(summary.requests.discovery_head.requests, 1);
assert_eq!(summary.requests.discovery_part.requests, 1);
assert_eq!(summary.requests.range.requests, 1);
assert!(
summary.requests.discovery_part.elapsed >= part_delay,
"the delayed layout GET accrues to its own request: {:?}",
summary.requests.discovery_part.elapsed,
);
assert!(
summary.requests.discovery_head.elapsed < part_delay / 10,
"HEAD discovery elapsed {:?} includes the {part_delay:?} re-issue",
summary.requests.discovery_head.elapsed,
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_cancellation_transitions_to_cancelled() {
let transfer = create_download(24 * MB, 8 * MB);
assert_discovery_succeeds(&transfer).await;
transfer.ctx().set_cancelled();
transfer.ctx().signal_terminal();
assert!(transfer.ctx().is_cancelled());
assert_done(transfer.poll_work());
}
fn create_download_for_gate(
object_size: u64,
part_size: u64,
) -> (
DownloadTransfer,
crate::operation::download::body::RecvBodyConsumer,
) {
create_download_for_gate_with_capacity(object_size, part_size, None)
}
fn create_download_for_gate_with_capacity(
object_size: u64,
part_size: u64,
capacity_bytes: Option<usize>,
) -> (
DownloadTransfer,
crate::operation::download::body::RecvBodyConsumer,
) {
let chunk = vec![0u8; part_size as usize];
let get_obj = mock!(aws_sdk_s3::Client::get_object).then_output(move || {
GetObjectOutput::builder()
.content_length(part_size as i64)
.content_range(format!("bytes 0-{}/{}", part_size - 1, object_size))
.e_tag("test-etag")
.body(ByteStream::from(chunk.clone()))
.build()
});
let client = mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[get_obj]);
let mut config = crate::Config::builder()
.sdk_client(client)
.part_size(crate::config::PartSize::Target(ByteSize::new(part_size)));
if let Some(capacity_bytes) = capacity_bytes {
let pool = crate::memory::BufferPool::builder()
.memory_budget(crate::config::MemoryBudgetConfig::Limit(ByteSize::new(
capacity_bytes as u64,
)))
.build()
.expect("test pool");
config = config.memory(crate::config::MemoryConfig::Explicit(pool));
}
let config = config.build().expect("valid config");
let handle = crate::client::Handle::test_handle_tokio(config);
let input = DownloadInput::builder()
.bucket("test-bucket")
.key("test-key")
.range(format!("bytes=0-{}", object_size - 1))
.build()
.unwrap();
let (writer, consumer) = crate::operation::download::body::new_recv_body();
let (ctx, _completion_rx) = TransferContext::new(handle);
let transfer = DownloadTransfer::new(ctx, BucketType::Standard, input, writer);
(transfer, consumer)
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_read_ahead_gate_bounds_issuance() {
let (transfer, _consumer) = create_download_for_gate(128 * MB, 8 * MB);
assert_discovery_succeeds(&transfer).await;
transfer.read_ahead().force_window(3);
let w = transfer.read_ahead().window();
let mut issued = 1u64;
loop {
match transfer.poll_work() {
PollWork::Ready { .. } => {
issued += 1;
assert!(issued <= w, "issuance ran past the window");
}
PollWork::Spawned => {}
PollWork::Pending => break,
PollWork::Done => panic!("unexpected Done"),
}
}
assert_eq!(issued, w, "issuance should fill the window then stall");
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_consume_reopens_gate() {
let (transfer, mut consumer) = create_download_for_gate(128 * MB, 8 * MB);
assert_discovery_succeeds(&transfer).await;
transfer.read_ahead().force_window(3);
while let PollWork::Ready { .. } = transfer.poll_work() {}
assert_pending(transfer.poll_work());
assert!(
consumer.try_take_next().is_some(),
"discovery chunk should deliver"
);
transfer.release_stream_occupancy();
assert_ready(transfer.poll_work());
assert_pending(transfer.poll_work());
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_memory_admission_blocks_then_resumes_in_fifo_order() {
let part_size = 8 * MB;
let object_size = 3 * part_size;
let capacity_bytes = 2 * part_size as usize;
let (transfer, mut consumer) =
create_download_for_gate_with_capacity(object_size, part_size, Some(capacity_bytes));
assert_discovery_succeeds(&transfer).await;
let pool = transfer.ctx().handle.buffer_pool.clone();
assert_eq!(
pool.metrics().active_planned_demand_bytes(),
0,
"the completed discovery response has closed acquisition authority"
);
assert_eq!(
pool.metrics().admitted_bytes(),
part_size,
"the delivered discovery payload remains charged"
);
let _w1 = assert_ready(transfer.poll_work());
assert_eq!(pool.metrics().active_planned_demand_bytes(), part_size);
assert_eq!(pool.metrics().admitted_bytes(), 2 * part_size);
assert_pending(transfer.poll_work());
assert_eq!(pool.metrics().waiting_requests(), 1);
{
let state = transfer.inner.state.lock().unwrap();
match &*state {
DownloadState::Transferring { pending, .. } => {
assert!(pending.is_some(), "claim should be waiting for memory");
}
_ => panic!("expected Transferring"),
}
}
drop(consumer.try_take_next().expect("discovery chunk is filled"));
assert_eq!(
pool.metrics().admitted_bytes(),
2 * part_size,
"freed capacity re-granted to the memory waiter"
);
assert_eq!(pool.metrics().waiting_requests(), 0);
let _w2 = assert_ready(transfer.poll_work());
{
let state = transfer.inner.state.lock().unwrap();
match &*state {
DownloadState::Transferring { pending, .. } => {
assert!(pending.is_none(), "waiting claim should be consumed");
}
_ => panic!("expected Transferring"),
}
}
assert_eq!(pool.metrics().active_planned_demand_bytes(), 2 * part_size);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_memory_reservation_failure_terminates_without_dispatch() {
let (transfer, _consumer) = create_download_for_gate(3 * 8 * MB, 8 * MB);
assert_discovery_succeeds(&transfer).await;
transfer
.ctx()
.handle
.buffer_pool
.inject_reservation_failure(ReserveError::MetadataAllocationFailed);
assert_done(transfer.poll_work());
assert!(transfer.ctx().is_failed());
assert_eq!(
transfer.ctx().error_kind(),
Some(crate::error::ErrorKind::RuntimeError),
);
assert!(matches!(
&*transfer.inner.state.lock().unwrap(),
DownloadState::Terminal
));
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_stream_memory_wait_does_not_emit_drain_resident() {
let part_size = 8 * MB;
let object_size = 3 * part_size;
let (transfer, _consumer) = create_download_for_gate_with_capacity(
object_size,
part_size,
Some(2 * part_size as usize),
);
assert_discovery_succeeds(&transfer).await;
let _part_1 = assert_ready(transfer.poll_work());
match transfer.poll_work() {
PollWork::Pending => {}
PollWork::Spawned => panic!("unexpected Spawned"),
PollWork::Ready { .. } => {
panic!("stream-mode memory wait must not emit DrainResident")
}
PollWork::Done => panic!("unexpected Done"),
}
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_cancel_while_memory_blocked_releases_future_and_slot() {
let part_size = 8 * MB;
let object_size = 3 * part_size;
let (transfer, mut consumer) = create_download_for_gate_with_capacity(
object_size,
part_size,
Some(2 * part_size as usize),
);
assert_discovery_succeeds(&transfer).await;
let pool = transfer.ctx().handle.buffer_pool.clone();
let _w1 = assert_ready(transfer.poll_work());
assert_pending(transfer.poll_work());
assert_eq!(
pool.metrics().waiting_requests(),
1,
"part 2's reservation is queued for memory"
);
assert!(transfer.ctx().set_cancelled());
transfer.on_terminal();
assert_eq!(
pool.metrics().waiting_requests(),
0,
"cancel must dequeue the memory waiter"
);
assert_eq!(
pool.metrics().active_planned_demand_bytes(),
part_size,
"only part 1 retains acquisition authority; the waiter was not granted"
);
assert_eq!(
pool.metrics().admitted_bytes(),
2 * part_size,
"the discovery payload and part-1 reservation remain charged"
);
let _ = consumer.try_take_next();
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_cancel_while_discovery_waits_for_memory_admission() {
let part_size = 8 * MB;
let (transfer, _consumer) =
create_download_for_gate_with_capacity(part_size, part_size, Some(part_size as usize));
let pool = transfer.ctx().handle.buffer_pool.clone();
let blocker = pool
.try_reserve(part_size as usize)
.unwrap()
.expect("test blocker");
let mut work = assert_ready(transfer.poll_work());
let executing = transfer.clone();
let task = tokio::spawn(async move { execute(&executing, &mut work).await });
tokio::time::timeout(std::time::Duration::from_secs(5), async {
while pool.metrics().waiting_requests() != 1 {
tokio::task::yield_now().await;
}
})
.await
.expect("discovery reservation should enter the memory FIFO");
assert!(transfer.ctx().set_cancelled());
transfer.on_terminal();
assert!(matches!(task.await.unwrap(), WorkOutcome::Cancelled));
assert_eq!(
pool.metrics().waiting_requests(),
0,
"terminal notification must cancel the discovery reservation future"
);
drop(blocker);
assert_eq!(pool.metrics().active_planned_demand_bytes(), 0);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_fail_while_memory_blocked_releases_future_and_slot() {
let part_size = 8 * MB;
let object_size = 3 * part_size;
let (transfer, mut consumer) = create_download_for_gate_with_capacity(
object_size,
part_size,
Some(2 * part_size as usize),
);
assert_discovery_succeeds(&transfer).await;
let pool = transfer.ctx().handle.buffer_pool.clone();
let _w1 = assert_ready(transfer.poll_work());
assert_pending(transfer.poll_work());
assert_eq!(
pool.metrics().waiting_requests(),
1,
"part 2's reservation is queued for memory"
);
let err = error::Error::new(error::ErrorKind::RuntimeError, "injected test failure");
{
let guard = transfer.inner.state.lock().unwrap();
let _ = transfer.fail(guard, err);
}
assert_eq!(
pool.metrics().waiting_requests(),
0,
"fail must dequeue the memory waiter"
);
assert_eq!(
pool.metrics().active_planned_demand_bytes(),
part_size,
"only part 1 retains acquisition authority; the waiter was not granted"
);
assert_eq!(
pool.metrics().admitted_bytes(),
2 * part_size,
"the discovery payload and part-1 reservation remain charged"
);
let _ = consumer.try_take_next();
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_terminal_drain_and_carrier_return_happen_in_execute() {
let part_size = 8 * MB;
let object_size = part_size;
let chunk = vec![0u8; part_size as usize];
let get_obj = mock!(aws_sdk_s3::Client::get_object).then_output(move || {
GetObjectOutput::builder()
.content_length(part_size as i64)
.content_range(format!("bytes 0-{}/{}", part_size - 1, object_size))
.e_tag("test-etag")
.body(ByteStream::from(chunk.clone()))
.build()
});
let client = mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[get_obj]);
let pool = crate::memory::BufferPool::builder()
.memory_budget(crate::config::MemoryBudgetConfig::Limit(ByteSize::new(
(part_size as usize) as u64,
)))
.build()
.expect("test pool");
let config = crate::Config::builder()
.sdk_client(client)
.part_size(crate::config::PartSize::Target(ByteSize::new(part_size)))
.memory(crate::config::MemoryConfig::Explicit(pool.clone()))
.diagnostics_for_test(crate::config::MemoryDiagnosticsConfig::default(), 1)
.build()
.expect("valid config");
let handle = crate::client::Handle::test_handle_tokio(config);
let input = DownloadInput::builder()
.bucket("test-bucket")
.key("test-key")
.range(format!("bytes=0-{}", object_size - 1))
.build()
.unwrap();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("out");
let file = std::fs::File::create(&path).unwrap();
let (writer, _consumer) =
crate::operation::download::body::new_recv_body_with_sink(file, false);
let (ctx, _completion_rx) = TransferContext::new(handle);
let transfer = DownloadTransfer::new(ctx, BucketType::Standard, input, writer);
assert_eq!(pool.metrics().active_planned_demand_bytes(), 0);
let mut work = assert_ready(transfer.poll_work());
let outcome = execute(&transfer, &mut work).await;
assert!(
matches!(outcome, WorkOutcome::Success { .. }),
"expected Success, got {:?}",
outcome
);
assert_eq!(
pool.metrics().active_planned_demand_bytes(),
0,
"terminal drain + carrier return must happen in execute, not a later poll_work"
);
assert!(
!transfer.ctx().is_active(),
"transfer must be completed after terminal execute"
);
let summary = transfer
.test_terminal_summary()
.expect("file summary diagnostics enabled");
assert_eq!(summary.destination, DownloadDestination::File);
assert!(summary.destination_work.prepared);
assert!(summary.destination_work.file_finalized);
assert_eq!(summary.destination_work.terminal_drain_parts, 1);
assert_eq!(summary.metrics.disk_write, part_size);
let written = std::fs::read(&path).unwrap();
assert_eq!(
written.len(),
part_size as usize,
"all bytes should be flushed to disk"
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn disk_write_counts_bytes_written_not_received() {
use crate::operation::download::test_util::fixtures::{object_bytes, object_client};
let part_size = 5 * MB;
let object = object_bytes(3 * part_size as usize);
let handle = disk_test_handle(object_client(Arc::clone(&object)), part_size);
let (transfer, _consumer, dir) = disk_transfer(handle, &FileSinkFactory);
let path = dir.path().join("out");
assert_first_range_succeeds(&transfer).await;
let mut second = assert_ready(transfer.poll_work());
execute(&transfer, &mut second).await;
let metrics = transfer.ctx().metrics();
assert_eq!(metrics.network_rx, 2 * part_size);
assert_eq!(
metrics.disk_write, 0,
"two parts received below the drain batch, none written"
);
assert!(std::fs::read(&path).unwrap().is_empty());
let mut last = assert_ready(transfer.poll_work());
let outcome = execute(&transfer, &mut last).await;
assert!(matches!(outcome, WorkOutcome::Success { .. }));
assert_eq!(
transfer.ctx().transfer_status(),
crate::types::TransferStatus::Completed
);
assert_eq!(transfer.ctx().metrics().disk_write, object.len() as u64);
assert_eq!(std::fs::read(&path).unwrap(), &object[..]);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn disk_write_counts_runs_written_before_a_drain_fails() {
use crate::operation::download::recv_buffer::DEFAULT_SEG_SIZE;
use crate::operation::download::test_util::fixtures::{object_bytes, object_client};
use crate::operation::download::test_util::sink::{
Action, Event, Match, Op, ScriptedSinkFactory, WriteScript,
};
const RUN_LEN: u64 = 4;
let script = Arc::new(WriteScript::default()).on(
Match::NthWrite(3),
Action::Fail(std::io::ErrorKind::StorageFull),
);
let handle = disk_test_handle(object_client(object_bytes(1)), 5 * MB);
let (transfer, _consumer, dir) =
disk_transfer(handle, &ScriptedSinkFactory(Arc::clone(&script)));
let writer = transfer.writer();
writer.prepare(0, 3 * RUN_LEN).unwrap();
let seg = DEFAULT_SEG_SIZE as u64;
for seq in 0..=2 * seg {
let slot = writer.claim();
if seq % seg == 0 {
let run = seq / seg;
slot.fill(ChunkOutput {
seq,
offset: run * RUN_LEN,
data: SegmentedBytes::from(Bytes::from(vec![run as u8 + 1; RUN_LEN as usize])),
metadata: Default::default(),
});
}
}
let guard = transfer.inner.state.lock().unwrap();
let outcome = transfer.fail(
guard,
error::Error::new(
error::ErrorKind::IOError,
std::io::Error::other("range failed"),
),
);
assert!(matches!(outcome, WorkOutcome::Failed { .. }));
let third = Op::Write {
pos: 2 * RUN_LEN,
len: RUN_LEN as usize,
};
assert!(
script.events().contains(&Event::Finished(
third,
Err(std::io::ErrorKind::StorageFull)
)),
"the terminal drain reached the third run"
);
let disk_write = transfer.ctx().metrics().disk_write;
assert_eq!(
disk_write,
2 * RUN_LEN,
"the two runs written before the failing one are counted"
);
assert_eq!(disk_write, writer.written());
assert_eq!(
std::fs::read(dir.path().join("out")).unwrap(),
[[1u8; RUN_LEN as usize], [2u8; RUN_LEN as usize]].concat()
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn disk_write_counts_the_tail_written_by_a_failed_finalize() {
use crate::operation::download::test_util::fixtures::{object_bytes, object_client};
use crate::operation::download::test_util::sink::{
Action, Event, Match, Op, ScriptedSinkFactory, WriteScript,
};
const TIMEOUT: std::time::Duration = std::time::Duration::from_secs(5);
let part_size = 5 * MB;
let object = object_bytes(2 * part_size as usize);
let script = Arc::new(WriteScript::default()).on(Match::NthWrite(1), Action::Hold);
let handle = disk_test_handle(object_client(Arc::clone(&object)), part_size);
let (transfer, _consumer, _dir) =
disk_transfer(handle, &ScriptedSinkFactory(Arc::clone(&script)));
assert_first_range_succeeds(&transfer).await;
let writer = transfer.writer().clone();
let untracked = std::thread::spawn(move || writer.drain(DrainMode::Eager));
let held = script.wait_held(TIMEOUT);
assert_eq!(
held.op(),
Op::Write {
pos: 0,
len: part_size as usize
}
);
let mut last = assert_ready(transfer.poll_work());
let outcome = execute(&transfer, &mut last).await;
assert!(matches!(outcome, WorkOutcome::Failed { .. }));
let error = transfer
.ctx()
.take_error()
.expect("the failure is reported");
assert_eq!(error.kind(), &crate::error::ErrorKind::IOError);
let tail = Op::Write {
pos: part_size,
len: part_size as usize,
};
assert!(
script.events().contains(&Event::Finished(tail, Ok(()))),
"finalization's terminal drain wrote the tail"
);
let disk_write = transfer.ctx().metrics().disk_write;
assert_eq!(disk_write, part_size, "the tail is counted");
assert_eq!(disk_write, transfer.writer().written());
held.release();
untracked.join().unwrap().unwrap();
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn disk_write_after_failure_counts_only_bytes_written() {
use crate::operation::download::test_util::fixtures::object_bytes;
let part_size = 5 * MB;
let object = object_bytes(3 * part_size as usize);
let client = object_client_failing_at(Arc::clone(&object), part_size);
let (transfer, _consumer, dir) =
disk_transfer(disk_test_handle(client, part_size), &FileSinkFactory);
assert_first_range_succeeds(&transfer).await;
let mut failing = assert_ready(transfer.poll_work());
let mut behind = assert_ready(transfer.poll_work());
execute(&transfer, &mut behind).await;
assert_eq!(transfer.ctx().metrics().disk_write, 0);
let outcome = execute(&transfer, &mut failing).await;
assert!(matches!(outcome, WorkOutcome::Failed { .. }));
let metrics = transfer.ctx().metrics();
assert_eq!(metrics.network_rx, 2 * part_size);
assert_eq!(
metrics.disk_write, part_size,
"only the part ahead of the failed range was written"
);
assert_eq!(
std::fs::read(dir.path().join("out")).unwrap(),
&object[..part_size as usize]
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn accepted_range_supplies_frozen_crc_evidence() {
use crate::operation::download::test_util::fixtures::object_bytes;
let part_size = 5 * MB;
let object = object_bytes(2 * part_size as usize);
let (transfer, _consumer, dir) = disk_transfer(
disk_test_handle(crc32_object_client(Arc::clone(&object), None), part_size),
&FileSinkFactory,
);
transfer.inner.writer.sync_drain_batch(1);
assert_first_range_succeeds(&transfer).await;
let mut integrity = {
let mut state = transfer.inner.state.lock().unwrap();
let DownloadState::Transferring { integrity, .. } =
std::mem::replace(&mut *state, DownloadState::Terminal)
else {
panic!("first range must leave the second range outstanding");
};
integrity
};
let remaining = SegmentedBytes::from(Bytes::copy_from_slice(&object[part_size as usize..]));
integrity.record(
RangeCompletion::capture(part_size, &remaining, None, integrity.range_digest_plan())
.unwrap(),
);
assert_eq!(
integrity.finish().unwrap().checksum_validation(),
&crate::types::ChecksumValidation::Validated {
algorithm: crate::types::ChecksumAlgorithm::Crc32,
},
);
assert!(std::fs::read(dir.path().join("out")).unwrap() == object[..part_size as usize]);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn whole_object_mismatch_precedes_destination_finalization() {
use crate::operation::download::test_util::fixtures::{
crc32_object_client_with_stored_checksum, object_bytes,
};
use crate::operation::download::test_util::sink::{
Action, Event, Match, Op, ScriptedSinkFactory, WriteScript,
};
let part_size = 5 * MB;
let object = object_bytes(part_size as usize + 37);
let expected = aws_smithy_types::base64::encode(0u32.to_be_bytes());
let mut crc = aws_smithy_checksums::ChecksumAlgorithm::Crc32.into_impl();
crc.update(&object);
let computed = aws_smithy_types::base64::encode(crc.finalize());
assert_ne!(expected, computed, "the stored checksum must mismatch");
let script = Arc::new(WriteScript::default()).on(
Match::Finalize,
Action::Fail(std::io::ErrorKind::StorageFull),
);
let (transfer, _consumer, _dir) = disk_transfer(
disk_test_handle(
crc32_object_client_with_stored_checksum(object, None, expected.clone()),
part_size,
),
&ScriptedSinkFactory(Arc::clone(&script)),
);
assert_first_range_succeeds(&transfer).await;
let mut last = assert_ready(transfer.poll_work());
assert!(matches!(
execute(&transfer, &mut last).await,
WorkOutcome::Failed { .. }
));
let error = transfer
.ctx()
.take_error()
.expect("failed transfer records its error");
let error::ErrorKind::IntegrityError(detail) = error.kind() else {
panic!("whole-object mismatch must win over destination failure: {error:?}");
};
assert_eq!(
detail.algorithm(),
Some(&crate::types::ChecksumAlgorithm::Crc32)
);
assert_eq!(detail.expected(), Some(expected.as_str()));
assert_eq!(detail.computed(), Some(computed.as_str()));
assert_eq!(
transfer.ctx().transfer_status(),
crate::types::TransferStatus::Failed
);
assert!(transfer.integrity_checks().is_none());
assert!(!script
.events()
.iter()
.any(|event| matches!(event, Event::Started(Op::Finalize { .. }))));
assert_done(transfer.poll_work());
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn missing_whole_object_evidence_prevents_destination_finalization() {
use crate::operation::download::test_util::fixtures::object_bytes;
use crate::operation::download::test_util::sink::{
Event, Op, ScriptedSinkFactory, WriteScript,
};
let part_size = 5 * MB;
let script = Arc::new(WriteScript::default());
let (transfer, _consumer, _dir) = disk_transfer(
disk_test_handle(
crc32_object_client(object_bytes(part_size as usize + 37), None),
part_size,
),
&ScriptedSinkFactory(Arc::clone(&script)),
);
assert_first_range_succeeds(&transfer).await;
let mut last = assert_ready(transfer.poll_work());
let DownloadWork::GetObjectRange { digest_plan, .. } = last.data_mut::<DownloadWork>()
else {
panic!("last work item must be the second range");
};
*digest_plan = RangeDigestPlan::None;
assert!(matches!(
execute(&transfer, &mut last).await,
WorkOutcome::Failed { .. }
));
assert_eq!(
transfer.ctx().take_error().unwrap().kind(),
&error::ErrorKind::RuntimeError
);
assert_eq!(
transfer.ctx().transfer_status(),
crate::types::TransferStatus::Failed
);
assert!(transfer.integrity_checks().is_none());
assert!(!script
.events()
.iter()
.any(|event| matches!(event, Event::Started(Op::Finalize { .. }))));
assert_done(transfer.poll_work());
}
async fn crc32_download_terminal_checksum_validation(
failing_part: Option<u64>,
) -> Option<crate::types::ChecksumValidation> {
use crate::operation::download::test_util::fixtures::object_bytes;
let part_size = 5 * MB;
let object = object_bytes(3 * part_size as usize);
let config = crate::Config::builder()
.sdk_client(crc32_object_client(
object,
failing_part.map(|n| n * part_size),
))
.part_size(crate::config::PartSize::Target(ByteSize::new(part_size)))
.diagnostics_for_test(crate::config::MemoryDiagnosticsConfig::default(), 1)
.build()
.expect("valid config");
let (transfer, _consumer, _dir) = disk_transfer(
crate::client::Handle::test_handle_tokio(config),
&FileSinkFactory,
);
assert_first_range_succeeds(&transfer).await;
let mut second = assert_ready(transfer.poll_work());
let mut third = assert_ready(transfer.poll_work());
let outcome = execute(&transfer, &mut second).await;
assert!(
matches!(outcome, WorkOutcome::Success { .. }),
"{outcome:?}"
);
let outcome = execute(&transfer, &mut third).await;
assert_eq!(
matches!(outcome, WorkOutcome::Failed { .. }),
failing_part.is_some(),
"{outcome:?}"
);
transfer
.test_terminal_summary()
.expect("summary diagnostics enabled")
.checksum_validation
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn failed_download_reports_no_checksum_verdict() {
assert_eq!(
crc32_download_terminal_checksum_validation(Some(2)).await,
None
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn completed_download_reports_checksum_verdict() {
assert_eq!(
crc32_download_terminal_checksum_validation(None).await,
Some(crate::types::ChecksumValidation::Validated {
algorithm: crate::model::ChecksumAlgorithm::Crc32,
})
);
}
const HOLD_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(5);
fn published_verdict(transfer: &DownloadTransfer) -> Option<&crate::types::ChecksumValidation> {
transfer
.integrity_checks()
.map(crate::types::IntegrityChecks::checksum_validation)
}
fn validated_crc32() -> crate::types::ChecksumValidation {
crate::types::ChecksumValidation::Validated {
algorithm: crate::model::ChecksumAlgorithm::Crc32,
}
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn final_range_waits_for_an_in_flight_relief_write() {
use crate::operation::download::test_util::sink::{Action, Match, Op, WriteScript};
let script = Arc::new(WriteScript::default()).on(Match::NthWrite(1), Action::Hold);
let scenario = relief_scenario(&script).await;
let (transfer, path, object) = (&scenario.transfer, &scenario.path, &scenario.object);
let relief = spawn_relief(transfer, scenario.relief);
let held = script.wait_held(HOLD_TIMEOUT);
assert_eq!(
held.op(),
Op::Write {
pos: 0,
len: scenario.part_size as usize
}
);
drop(scenario.blocker);
let mut last = assert_ready(transfer.poll_work());
let outcome = execute(transfer, &mut last).await;
assert!(matches!(outcome, WorkOutcome::Success { .. }));
assert!(
transfer.ctx().is_active(),
"the transfer completed while a destination write was in flight"
);
assert_eq!(published_verdict(transfer), None);
assert_pending(transfer.poll_work());
assert_eq!(
std::fs::metadata(path).unwrap().len(),
0,
"the destination was resized while a destination write was in flight"
);
assert!(!finalize_started(&script.events()));
held.release();
let outcome = relief.join().unwrap();
assert!(matches!(outcome, WorkOutcome::Success { .. }));
assert_eq!(
transfer.ctx().transfer_status(),
crate::types::TransferStatus::Completed
);
assert_eq!(published_verdict(transfer), Some(&validated_crc32()));
assert_eq!(std::fs::read(path).unwrap(), &object[..]);
assert_eq!(transfer.ctx().metrics().disk_write, object.len() as u64);
assert_done(transfer.poll_work());
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn failed_relief_write_after_final_range_fails_the_transfer() {
use crate::operation::download::test_util::sink::{Action, Match, WriteScript};
let script = Arc::new(WriteScript::default()).on(Match::NthWrite(1), Action::Hold);
let scenario = relief_scenario(&script).await;
let transfer = &scenario.transfer;
let relief = spawn_relief(transfer, scenario.relief);
let held = script.wait_held(HOLD_TIMEOUT);
drop(scenario.blocker);
let mut last = assert_ready(transfer.poll_work());
execute(transfer, &mut last).await;
assert!(transfer.ctx().is_active());
held.release_err(std::io::ErrorKind::StorageFull);
let outcome = relief.join().unwrap();
assert!(matches!(outcome, WorkOutcome::Failed { .. }));
assert!(transfer.ctx().is_failed());
let error = transfer
.ctx()
.take_error()
.expect("the failure is reported");
assert_eq!(error.kind(), &crate::error::ErrorKind::IOError);
assert_eq!(published_verdict(transfer), None);
assert!(
!finalize_started(&script.events()),
"a failed transfer must not finalize its destination"
);
assert_eq!(
transfer.ctx().metrics().disk_write,
scenario.part_size,
"only the final part, written by the terminal drain, reached the destination"
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn relief_after_terminal_transition_writes_nothing() {
use crate::operation::download::test_util::sink::WriteScript;
let script = Arc::new(WriteScript::default());
let scenario = relief_scenario(&script).await;
let transfer = &scenario.transfer;
assert!(transfer.ctx().set_cancelled());
transfer.on_terminal();
let events = script.events();
let outcome = spawn_relief(transfer, scenario.relief).join().unwrap();
assert!(matches!(outcome, WorkOutcome::Cancelled));
assert_eq!(script.events(), events, "a moot relief item must not write");
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn memory_blocked_poll_with_a_queued_relief_item_parks() {
use crate::operation::download::test_util::sink::{Event, Op, WriteScript};
let script = Arc::new(WriteScript::default());
let mut scenario = relief_scenario(&script).await;
let transfer = &scenario.transfer;
assert!(
transfer.writer().has_drainable_resident(),
"the queued item has not drained the first part yet"
);
assert_pending(transfer.poll_work());
let outcome = execute(transfer, &mut scenario.relief).await;
assert!(matches!(outcome, WorkOutcome::Success { .. }));
let first_part = Op::Write {
pos: 0,
len: scenario.part_size as usize,
};
assert_eq!(
script.events(),
[
Event::Started(first_part),
Event::Finished(first_part, Ok(()))
],
"one relief item drained the resident run"
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn final_range_waits_for_a_queued_relief_item() {
use crate::operation::download::test_util::sink::WriteScript;
let script = Arc::new(WriteScript::default());
let mut scenario = relief_scenario(&script).await;
let transfer = &scenario.transfer;
drop(scenario.blocker);
let mut last = assert_ready(transfer.poll_work());
let outcome = execute(transfer, &mut last).await;
assert!(matches!(outcome, WorkOutcome::Success { .. }));
assert!(
transfer.ctx().is_active(),
"the transfer completed while a relief item was queued"
);
assert_eq!(published_verdict(transfer), None);
assert_pending(transfer.poll_work());
assert!(!finalize_started(&script.events()));
let outcome = execute(transfer, &mut scenario.relief).await;
assert!(matches!(outcome, WorkOutcome::Success { .. }));
assert_eq!(
transfer.ctx().transfer_status(),
crate::types::TransferStatus::Completed
);
assert_eq!(published_verdict(transfer), Some(&validated_crc32()));
assert_eq!(std::fs::read(&scenario.path).unwrap(), &scenario.object[..]);
assert_done(transfer.poll_work());
}
struct HeldReliefDownload {
result: Result<crate::operation::download::DownloadOutput, crate::error::Error>,
object: std::sync::Arc<[u8]>,
dest: std::path::PathBuf,
dir: tempfile::TempDir,
}
async fn write_to_path_with_held_relief_write(
release_err: Option<std::io::ErrorKind>,
max_partitions: usize,
) -> HeldReliefDownload {
use crate::operation::download::test_util::fixtures::{
managed_test_handle_with_max_partitions, object_bytes,
};
use crate::operation::download::test_util::sink::{
Action, Match, Op, ScriptedSinkFactory, WriteScript,
};
use crate::operation::download::Download;
use std::sync::Arc;
use std::time::Duration;
const TIMEOUT: Duration = Duration::from_secs(5);
let part_size = 8 * 1024 * 1024;
let object = object_bytes(2 * part_size);
let pool = crate::memory::BufferPool::builder()
.memory_budget(crate::config::MemoryBudgetConfig::Limit(ByteSize::new(
2 * part_size as u64,
)))
.build()
.expect("test pool");
let blocker = pool
.try_reserve(part_size)
.unwrap()
.expect("the budget fits the blocker");
let script = Arc::new(WriteScript::default()).on(Match::NthWrite(1), Action::Hold);
let config = crate::Config::builder()
.sdk_client(crc32_object_client(Arc::clone(&object), None))
.part_size(crate::config::PartSize::Target(ByteSize::new(
part_size as u64,
)))
.memory(crate::config::MemoryConfig::Explicit(pool))
.build()
.expect("valid config");
let (handle, partition_count) =
managed_test_handle_with_max_partitions(config, 2, max_partitions);
let input = DownloadInput::builder()
.bucket("test-bucket")
.key("test-key")
.build()
.unwrap();
let dir = tempfile::tempdir().unwrap();
let dest = dir.path().join("object");
let download = Download::orchestrate_to_path(
Arc::clone(&handle),
input,
dest.clone(),
None,
&ScriptedSinkFactory(Arc::clone(&script)),
)
.await
.unwrap();
let held = tokio::task::spawn_blocking({
let script = Arc::clone(&script);
move || script.wait_held(TIMEOUT)
})
.await
.unwrap();
assert_eq!(
held.op(),
Op::Write {
pos: 0,
len: part_size
}
);
drop(blocker);
if partition_count > 1 {
tokio::time::timeout(TIMEOUT, async {
while download.metrics().network_rx < 2 * part_size as u64 {
tokio::time::sleep(Duration::from_millis(1)).await;
}
})
.await
.expect("the final range is received while the relief write is held");
}
let join = tokio::spawn(download.join());
tokio::time::sleep(Duration::from_millis(200)).await;
assert!(
!join.is_finished(),
"join returned while a destination write was in flight"
);
assert!(
!dest.exists(),
"the destination was published while a destination write was in flight"
);
match release_err {
None => held.release(),
Some(kind) => held.release_err(kind),
}
let result = tokio::time::timeout(TIMEOUT, join)
.await
.expect("join returns once the write is released")
.unwrap();
crate::runtime::test_util::shutdown(&handle).await;
HeldReliefDownload {
result,
object,
dest,
dir,
}
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn write_to_path_join_waits_for_a_held_relief_write() {
let download = write_to_path_with_held_relief_write(None, 4).await;
let output = download.result.expect("the download succeeds");
assert_eq!(std::fs::read(&download.dest).unwrap(), &download.object[..]);
assert_eq!(
output.integrity_checks().checksum_validation(),
&validated_crc32()
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn write_to_path_fails_without_publishing_when_a_relief_write_fails() {
let download =
write_to_path_with_held_relief_write(Some(std::io::ErrorKind::StorageFull), 4).await;
let error = download.result.expect_err("the relief write failed");
assert_eq!(error.kind(), &crate::error::ErrorKind::IOError);
assert!(
!download.dest.exists(),
"a failed download must not publish"
);
assert_eq!(
std::fs::read_dir(download.dir.path()).unwrap().count(),
0,
"the temporary file must be removed"
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn held_relief_write_on_one_partition_preserves_completion_and_cleanup() {
let download = write_to_path_with_held_relief_write(None, 1).await;
let output = download
.result
.expect("download succeeds after the write is released");
assert_eq!(std::fs::read(&download.dest).unwrap(), &download.object[..]);
assert_eq!(
output.integrity_checks().checksum_validation(),
&validated_crc32()
);
let download =
write_to_path_with_held_relief_write(Some(std::io::ErrorKind::StorageFull), 1).await;
assert_eq!(
download.result.unwrap_err().kind(),
&crate::error::ErrorKind::IOError
);
assert!(!download.dest.exists());
assert_eq!(std::fs::read_dir(download.dir.path()).unwrap().count(), 0);
}
#[cfg(debug_assertions)]
#[cfg_attr(miri, ignore)]
#[tokio::test]
#[should_panic(expected = "download failed after it had completed")]
async fn failure_after_completion_panics_in_debug_builds() {
let transfer = create_download(8 * MB, 8 * MB);
assert_first_range_succeeds(&transfer).await;
assert_eq!(
transfer.ctx().transfer_status(),
crate::types::TransferStatus::Completed
);
let guard = transfer.inner.state.lock().unwrap();
let _ = transfer.fail(
guard,
error::Error::new(
error::ErrorKind::IOError,
std::io::Error::other("late destination failure"),
),
);
}
#[cfg(not(debug_assertions))]
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn failure_after_completion_is_logged_in_release_builds() {
use aws_smithy_runtime::test_util::capture_test_logs::capture_test_logs;
let transfer = create_download(8 * MB, 8 * MB);
assert_first_range_succeeds(&transfer).await;
assert_eq!(
transfer.ctx().transfer_status(),
crate::types::TransferStatus::Completed
);
let (_guard, logs) = capture_test_logs();
let guard = transfer.inner.state.lock().unwrap();
let _ = transfer.fail(
guard,
error::Error::new(
error::ErrorKind::IOError,
std::io::Error::other("late destination failure"),
),
);
assert_eq!(
transfer.ctx().transfer_status(),
crate::types::TransferStatus::Completed
);
let logs = logs.contents();
let logged = |level: &str, message: &str| {
logs.lines().any(|line| {
line.contains(level)
&& line.contains(message)
&& line.contains("late destination failure")
})
};
assert!(logged("DEBUG", "download failed"), "{logs}");
assert!(
logged("ERROR", "download failed after it had completed"),
"{logs}"
);
}
#[cfg(test)]
async fn drive_to_completion(transfers: &[&DownloadTransfer]) {
let mut done = vec![false; transfers.len()];
let max_steps = 10_000;
for _ in 0..max_steps {
if done.iter().all(|d| *d) {
return;
}
let mut progressed = false;
for (i, t) in transfers.iter().enumerate() {
if done[i] {
continue;
}
match t.poll_work() {
PollWork::Ready { io: mut work, .. } => {
execute(t, &mut work).await;
progressed = true;
}
PollWork::Done => {
done[i] = true;
progressed = true;
}
PollWork::Spawned => {
progressed = true;
}
PollWork::Pending => {}
}
}
if !progressed {
panic!(
"no transfer made progress: all Pending with work outstanding \
(memory-admission deadlock regressed)"
);
}
}
panic!("drive_to_completion exceeded {max_steps} steps without completing");
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_concurrent_multipart_disk_below_drain_batch_completes() {
let part_size = 8 * MB;
let object_size = 2 * part_size;
let get_obj = mock!(aws_sdk_s3::Client::get_object).then_compute_response(move |req| {
let start = req
.range()
.and_then(|r| r.parse::<crate::http::header::Range>().ok())
.map(|r| match r.0 {
crate::http::header::ByteRange::Inclusive(s, _) => s,
crate::http::header::ByteRange::AllFrom(s) => s,
_ => 0,
})
.unwrap_or(0);
let end = std::cmp::min(start + part_size, object_size) - 1;
let chunk = vec![0u8; (end - start + 1) as usize];
aws_smithy_mocks::MockResponse::Output(
GetObjectOutput::builder()
.content_length((end - start + 1) as i64)
.content_range(format!("bytes {}-{}/{}", start, end, object_size))
.e_tag("test-etag")
.body(ByteStream::from(chunk))
.build(),
)
});
let pool = crate::memory::BufferPool::builder()
.memory_budget(crate::config::MemoryBudgetConfig::Limit(ByteSize::new(
2 * part_size,
)))
.build()
.expect("test pool");
let config = crate::Config::builder()
.sdk_client(mock_client!(
aws_sdk_s3,
RuleMode::MatchAny,
&[head_rule(object_size), get_obj]
))
.part_size(crate::config::PartSize::Target(ByteSize::new(part_size)))
.memory(crate::config::MemoryConfig::Explicit(pool.clone()))
.build()
.expect("valid config");
let handle = crate::client::Handle::test_handle_tokio(config);
let (a, _ca, _da) = disk_transfer(handle.clone(), &FileSinkFactory);
let (b, _cb, _db) = disk_transfer(handle.clone(), &FileSinkFactory);
drive_to_completion(&[&a, &b]).await;
assert!(!a.ctx().is_active(), "transfer A completed");
assert!(!b.ctx().is_active(), "transfer B completed");
assert_eq!(
pool.metrics().active_planned_demand_bytes(),
0,
"all reservations released after both transfers complete"
);
assert_eq!(
pool.metrics().waiting_requests(),
0,
"no memory waiters remain"
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_concurrent_large_multipart_partial_fills_complete() {
let part_size = 8 * MB;
let parts_per_object = 20u64; let object_size = parts_per_object * part_size;
let resident_per_transfer = 3u64;
let get_obj = mock!(aws_sdk_s3::Client::get_object).then_compute_response(move |req| {
let start = req
.range()
.and_then(|r| r.parse::<crate::http::header::Range>().ok())
.map(|r| match r.0 {
crate::http::header::ByteRange::Inclusive(s, _) => s,
crate::http::header::ByteRange::AllFrom(s) => s,
_ => 0,
})
.unwrap_or(0);
let end = std::cmp::min(start + part_size, object_size) - 1;
let chunk = vec![0u8; (end - start + 1) as usize];
aws_smithy_mocks::MockResponse::Output(
GetObjectOutput::builder()
.content_length((end - start + 1) as i64)
.content_range(format!("bytes {}-{}/{}", start, end, object_size))
.e_tag("test-etag")
.body(ByteStream::from(chunk))
.build(),
)
});
let capacity_bytes = (2 * resident_per_transfer * part_size) as usize;
let pool = crate::memory::BufferPool::builder()
.memory_budget(crate::config::MemoryBudgetConfig::Limit(ByteSize::new(
capacity_bytes as u64,
)))
.build()
.expect("test pool");
let config = crate::Config::builder()
.sdk_client(mock_client!(
aws_sdk_s3,
RuleMode::MatchAny,
&[head_rule(object_size), get_obj]
))
.part_size(crate::config::PartSize::Target(ByteSize::new(part_size)))
.memory(crate::config::MemoryConfig::Explicit(pool.clone()))
.build()
.expect("valid config");
let handle = crate::client::Handle::test_handle_tokio(config);
let (a, _ca, _da) = disk_transfer(handle.clone(), &FileSinkFactory);
let (b, _cb, _db) = disk_transfer(handle.clone(), &FileSinkFactory);
async fn fill_resident(t: &DownloadTransfer, resident: u64) {
assert_first_range_succeeds(t).await; for _ in 1..resident {
let mut w = assert_ready(t.poll_work());
execute(t, &mut w).await;
}
}
fill_resident(&a, resident_per_transfer).await;
fill_resident(&b, resident_per_transfer).await;
assert_eq!(
pool.metrics().admitted_bytes(),
capacity_bytes as u64,
"both transfers hold charged resident parts; memory budget is exactly full"
);
drive_to_completion(&[&a, &b]).await;
assert!(!a.ctx().is_active(), "large-object transfer A completed");
assert!(!b.ctx().is_active(), "large-object transfer B completed");
assert_eq!(
pool.metrics().active_planned_demand_bytes(),
0,
"all reservations released after both large multipart transfers complete"
);
assert_eq!(
pool.metrics().waiting_requests(),
0,
"no memory waiters remain"
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_read_ahead_resolution_precedence() {
use crate::config::ReadAhead;
let build = |client_mode: ReadAhead, input_override: Option<ReadAhead>| {
let get_obj = mock!(aws_sdk_s3::Client::get_object).then_output(|| {
GetObjectOutput::builder()
.content_length(8 * MB as i64)
.content_range(format!("bytes 0-{}/{}", 8 * MB - 1, 8 * MB))
.e_tag("test-etag")
.body(ByteStream::from(vec![0u8; 8 * MB as usize]))
.build()
});
let config = crate::Config::builder()
.sdk_client(mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[get_obj]))
.part_size(crate::config::PartSize::Target(ByteSize::new(8 * MB)))
.read_ahead(client_mode)
.build()
.expect("valid config");
let handle = crate::client::Handle::test_handle_tokio(config);
let input = DownloadInput::builder()
.bucket("test-bucket")
.key("test-key")
.set_read_ahead(input_override)
.build()
.unwrap();
let (writer, _consumer) = crate::operation::download::body::new_recv_body();
let (ctx, _rx) = TransferContext::new(handle);
DownloadTransfer::new(ctx, BucketType::Standard, input, writer)
};
let t = build(ReadAhead::Parts(9), None);
assert_eq!(t.read_ahead().window(), 10, "client default applies");
let t = build(ReadAhead::Parts(9), Some(ReadAhead::Parts(3)));
assert_eq!(t.read_ahead().window(), 4, "request override wins");
let t = build(ReadAhead::Auto, None);
assert_eq!(
t.read_ahead().window(),
super::super::read_ahead::DEFAULT_WINDOW_PARTS
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_io_ctl_set_read_ahead_resizes_window() {
let (transfer, _consumer) = create_download_for_gate(128 * MB, 8 * MB);
assert_first_range_succeeds(&transfer).await;
transfer
.io_ctl()
.set_read_ahead(crate::config::ReadAhead::Parts(4));
assert_eq!(transfer.read_ahead().window(), 5);
transfer
.io_ctl()
.set_read_ahead(crate::config::ReadAhead::Parts(0));
assert_eq!(transfer.read_ahead().window(), 1);
transfer
.io_ctl()
.set_read_ahead(crate::config::ReadAhead::Auto);
assert_eq!(
transfer.read_ahead().window(),
super::super::read_ahead::DEFAULT_WINDOW_PARTS
);
}
use crate::http::header::Range;
use aws_smithy_mocks::MockResponse;
use aws_smithy_runtime::test_util::capture_test_logs::show_test_logs;
use aws_smithy_runtime_api::http::{Response, StatusCode};
use aws_smithy_types::body::SdkBody;
use std::collections::HashMap;
#[derive(Clone)]
enum FailureBehavior {
Always,
#[allow(dead_code)] Times(usize),
}
struct FailureConfig {
object_size: u64,
part_size: u64,
failures: HashMap<u64, FailureBehavior>,
detail: u64,
}
impl FailureConfig {
fn new(object_size: u64, part_size: u64) -> Self {
Self {
object_size,
part_size,
failures: HashMap::new(),
detail: 0,
}
}
fn fail(mut self, seq: u64) -> Self {
self.failures.insert(seq, FailureBehavior::Always);
self
}
fn detail(mut self, detail: u64) -> Self {
self.detail = detail;
self
}
fn build(self) -> DownloadTransfer {
let object_size = self.object_size;
let part_size = self.part_size;
let detail = self.detail;
let failures = Arc::new(self.failures);
let call_counts: Arc<std::sync::Mutex<HashMap<u64, usize>>> =
Arc::new(std::sync::Mutex::new(HashMap::new()));
let get_obj = mock!(aws_sdk_s3::Client::get_object).then_compute_response(move |req| {
let seq = req
.range()
.and_then(|r| r.parse::<Range>().ok())
.map(|r| match r.0 {
crate::http::header::ByteRange::Inclusive(start, _) => start / part_size,
crate::http::header::ByteRange::AllFrom(start) => start / part_size,
_ => 0,
})
.unwrap_or(0);
let mut counts = call_counts.lock().unwrap();
let call_num = *counts.entry(seq).and_modify(|c| *c += 1).or_insert(1);
drop(counts);
let should_fail = match failures.get(&seq) {
Some(FailureBehavior::Always) => true,
Some(FailureBehavior::Times(n)) => call_num <= *n,
None => false,
};
if should_fail {
MockResponse::Http(Response::new(
StatusCode::try_from(500).unwrap(),
SdkBody::from("internal error"),
))
} else {
let start = seq * part_size;
let end = std::cmp::min(start + part_size, object_size) - 1;
let chunk = vec![0u8; (end - start + 1) as usize];
MockResponse::Output(
GetObjectOutput::builder()
.content_length((end - start + 1) as i64)
.content_range(format!("bytes {}-{}/{}", start, end, object_size))
.e_tag("test-etag")
.body(ByteStream::from(chunk))
.build(),
)
}
});
create_get_first_download_with_client_and_detail(
mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[get_obj], |conf| {
conf.retry_config(aws_sdk_s3::config::retry::RetryConfig::disabled())
}),
part_size,
detail,
Some(object_size),
)
}
}
#[test]
fn test_validate_content_range_success() {
assert!(validate_content_range(
"bytes=1024-2047",
Some("bytes 1024-2047/4096"),
None,
None
)
.is_ok());
assert!(
validate_content_range("1024-2047", Some("bytes 1024-2047/4096"), None, None).is_ok()
);
}
#[test]
fn test_validate_content_range_mismatch() {
assert!(validate_content_range(
"bytes=1024-2047",
Some("bytes 2048-3071/4096"),
None,
None
)
.is_err());
}
#[test]
fn test_validate_content_range_missing() {
assert!(validate_content_range("bytes=1024-2047", None, None, None).is_err());
}
#[test]
fn test_validate_content_range_substring_false_positive() {
assert!(validate_content_range("bytes=0-9", Some("bytes 10-99/100"), None, None).is_err());
}
#[test]
fn test_validate_content_range_exact_match_small_range() {
assert!(validate_content_range("bytes=0-9", Some("bytes 0-9/100"), None, None).is_ok());
}
#[test]
fn test_validate_content_range_unsized_total() {
assert!(validate_content_range("bytes=0-9", Some("bytes 0-9/*"), None, None).is_ok());
}
#[test]
fn test_validate_content_range_large_range_match() {
assert!(
validate_content_range("bytes=100-199", Some("bytes 100-199/500"), None, None).is_ok()
);
}
#[test]
fn test_validate_content_range_response_none() {
assert!(validate_content_range("bytes=0-9", None, None, None).is_err());
}
#[test]
fn test_validate_content_range_complete_response_without_content_range() {
assert!(validate_content_range("bytes=0-4", None, Some(5), Some(5)).is_ok());
assert!(validate_content_range("bytes=0-4", None, Some(5), Some(10)).is_err());
assert!(validate_content_range("bytes=5-9", None, Some(10), Some(10)).is_err());
assert!(validate_content_range("bytes=0-4", None, Some(4), Some(5)).is_err());
assert!(validate_content_range("bytes=0-4", None, None, Some(5)).is_err());
assert!(validate_content_range("bytes=0-4", None, Some(5), None).is_err());
assert!(validate_content_range("bytes=0-4", Some("bytes abc"), Some(5), Some(5)).is_err());
}
#[test]
fn test_validate_content_range_garbage_response() {
assert!(validate_content_range("bytes=0-9", Some("bytes abc"), None, None).is_err());
}
#[test]
fn test_parse_byte_range_request_format() {
assert_eq!(parse_byte_range("bytes=0-9"), Some((0, 9)));
assert_eq!(parse_byte_range("bytes=100-199"), Some((100, 199)));
}
#[test]
fn test_parse_byte_range_response_format() {
assert_eq!(parse_byte_range("bytes 0-9/100"), Some((0, 9)));
assert_eq!(parse_byte_range("bytes 100-199/500"), Some((100, 199)));
assert_eq!(parse_byte_range("bytes 0-9/*"), Some((0, 9)));
}
#[test]
fn test_parse_byte_range_invalid() {
assert_eq!(parse_byte_range("bytes abc"), None);
assert_eq!(parse_byte_range(""), None);
assert_eq!(parse_byte_range("bytes 9-0"), None); }
}