use std::sync::Arc;
use super::sink::{Event, Op, ScriptedSinkFactory, WriteScript};
use crate::operation::download::body::{new_recv_body_with_disk_mode, RecvBodyConsumer};
use crate::operation::download::sink::SinkFactory;
use crate::operation::download::transfer::DownloadWork;
use crate::operation::download::{DownloadInput, DownloadTransfer};
use crate::runtime::buffer_pool::Reservation;
use crate::scheduler::test_util::assert_ready;
use crate::transfer::{IoRequest, TransferContext, WorkOutcome};
use crate::types::{BucketType, ByteSize};
pub(crate) fn object_bytes(len: usize) -> Arc<[u8]> {
(0..len).map(|i| (i % 251) as u8 + 1).collect()
}
pub(crate) fn head_rule(object_len: u64) -> aws_smithy_mocks::Rule {
aws_smithy_mocks::mock!(aws_sdk_s3::Client::head_object).then_output(move || {
aws_sdk_s3::operation::head_object::HeadObjectOutput::builder()
.content_length(object_len as i64)
.e_tag("test-etag")
.build()
})
}
pub(crate) fn object_client(object: Arc<[u8]>) -> aws_sdk_s3::Client {
use aws_sdk_s3::operation::get_object::GetObjectOutput;
use aws_sdk_s3::primitives::ByteStream;
use aws_smithy_mocks::{mock, mock_client, MockResponse, RuleMode};
use crate::http::header::{ByteRange, Range};
let head = head_rule(object.len() as u64);
let get = mock!(aws_sdk_s3::Client::get_object).then_compute_response(move |req| {
let last = object.len() as u64 - 1;
let (start, end) = match req.range().and_then(|r| r.parse::<Range>().ok()) {
Some(Range(ByteRange::Inclusive(start, end))) => (start, end.min(last)),
Some(Range(ByteRange::AllFrom(start))) => (start, last),
_ => (0, last),
};
let body = object[start as usize..=end as usize].to_vec();
MockResponse::Output(
GetObjectOutput::builder()
.content_length(body.len() as i64)
.content_range(format!("bytes {start}-{end}/{}", object.len()))
.e_tag("test-etag")
.body(ByteStream::from(body))
.build(),
)
});
mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[head, get])
}
pub(crate) fn object_client_failing_at(
object: Arc<[u8]>,
failing_start: u64,
) -> aws_sdk_s3::Client {
use aws_sdk_s3::operation::get_object::GetObjectOutput;
use aws_sdk_s3::primitives::ByteStream;
use aws_smithy_mocks::MockResponse;
let object_len = object.len();
strict_range_client(
object,
Some(failing_start),
None,
move |start, end, body| {
MockResponse::Output(
GetObjectOutput::builder()
.content_length(body.len() as i64)
.content_range(format!("bytes {start}-{end}/{object_len}"))
.e_tag("test-etag")
.body(ByteStream::from(body.to_vec()))
.build(),
)
},
)
}
pub(crate) fn crc32_object_client(
object: Arc<[u8]>,
failing_start: Option<u64>,
) -> aws_sdk_s3::Client {
let mut checksum = aws_smithy_checksums::ChecksumAlgorithm::Crc32.into_impl();
checksum.update(&object);
crc32_object_client_with_stored_checksum(
object,
failing_start,
aws_smithy_types::base64::encode(checksum.finalize()),
)
}
pub(crate) fn crc32_object_client_with_stored_checksum(
object: Arc<[u8]>,
failing_start: Option<u64>,
stored_checksum: String,
) -> aws_sdk_s3::Client {
use aws_smithy_mocks::MockResponse;
use aws_smithy_runtime_api::http::{Response, StatusCode};
use aws_smithy_types::body::SdkBody;
let object_len = object.len();
strict_range_client(
object,
failing_start,
Some(stored_checksum),
move |start, end, body| {
let mut crc32 = aws_smithy_checksums::ChecksumAlgorithm::Crc32.into_impl();
crc32.update(body);
let mut response = Response::new(
StatusCode::try_from(200).unwrap(),
SdkBody::from(body.to_vec()),
);
let headers = response.headers_mut();
headers.insert("content-length", body.len().to_string());
headers.insert("content-range", format!("bytes {start}-{end}/{object_len}"));
headers.insert("etag", "test-etag");
headers.insert(
"x-amz-checksum-crc32",
aws_smithy_types::base64::encode(crc32.finalize()),
);
MockResponse::Http(response)
},
)
}
fn strict_range_client(
object: Arc<[u8]>,
failing_start: Option<u64>,
object_checksum: Option<String>,
respond: impl Fn(
u64,
u64,
&[u8],
) -> aws_smithy_mocks::MockResponse<
aws_sdk_s3::operation::get_object::GetObjectOutput,
aws_sdk_s3::operation::get_object::GetObjectError,
> + Send
+ Sync
+ 'static,
) -> aws_sdk_s3::Client {
use aws_smithy_mocks::{mock, mock_client, MockResponse, RuleMode};
use aws_smithy_runtime_api::http::{Response, StatusCode};
use aws_smithy_types::body::SdkBody;
use crate::http::header::{ByteRange, Range};
let object_len = object.len() as i64;
let head = mock!(aws_sdk_s3::Client::head_object).then_output(move || {
aws_sdk_s3::operation::head_object::HeadObjectOutput::builder()
.content_length(object_len)
.e_tag("test-etag")
.set_checksum_crc32(object_checksum.clone())
.build()
});
let get = mock!(aws_sdk_s3::Client::get_object).then_compute_response(move |req| {
let (start, end) = match req.range().and_then(|r| r.parse::<Range>().ok()) {
Some(Range(ByteRange::Inclusive(start, end))) => {
(start, end.min(object.len() as u64 - 1))
}
other => panic!("unexpected range request {other:?}"),
};
if Some(start) == failing_start {
return MockResponse::Http(Response::new(
StatusCode::try_from(500).unwrap(),
SdkBody::from("internal error"),
));
}
respond(start, end, &object[start as usize..=end as usize])
});
mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[head, get], |conf| {
conf.retry_config(aws_sdk_s3::config::retry::RetryConfig::disabled())
})
}
pub(crate) fn disk_test_handle(
client: aws_sdk_s3::Client,
part_size: u64,
) -> Arc<crate::client::Handle> {
let config = crate::Config::builder()
.sdk_client(client)
.part_size(crate::config::PartSize::Target(ByteSize::new(part_size)))
.build()
.expect("valid config");
crate::client::Handle::test_handle_tokio(config)
}
pub(crate) fn managed_test_handle(
config: crate::Config,
concurrency: usize,
) -> Arc<crate::client::Handle> {
managed_test_handle_with_max_partitions(config, concurrency, 4).0
}
pub(crate) fn managed_test_handle_with_max_partitions(
config: crate::Config,
concurrency: usize,
max_partitions: usize,
) -> (Arc<crate::client::Handle>, usize) {
let mut partition_count = 0;
let handle = crate::client::Handle::new_for_test_with_runtime(
config,
Arc::new(crate::scheduler::FixedConcurrency::new(concurrency)),
|weak| {
let execution = crate::runtime::ManagedExecution::for_test(weak, max_partitions);
partition_count = execution.partition_count();
Arc::new(execution)
},
);
(handle, partition_count)
}
pub(crate) fn disk_transfer(
handle: Arc<crate::client::Handle>,
sinks: &dyn SinkFactory,
) -> (DownloadTransfer, RecvBodyConsumer, tempfile::TempDir) {
let input = DownloadInput::builder()
.bucket("test-bucket")
.key("test-key")
.build()
.unwrap();
let dir = tempfile::tempdir().unwrap();
let file = std::fs::File::create(dir.path().join("out")).unwrap();
let (writer, consumer) = new_recv_body_with_disk_mode(sinks.create(file, false).unwrap());
let (ctx, _completion_rx) = TransferContext::new(handle);
let transfer = DownloadTransfer::new(ctx, BucketType::Standard, input, writer);
(transfer, consumer, dir)
}
pub(crate) async fn execute(transfer: &DownloadTransfer, work: &mut IoRequest) -> WorkOutcome {
transfer.execute(work).await
}
pub(crate) async fn assert_discovery_succeeds(transfer: &DownloadTransfer) {
let mut work = assert_ready(transfer.poll_work());
let outcome = execute(transfer, &mut work).await;
assert!(
matches!(outcome, WorkOutcome::Success { .. }),
"discovery failed: {outcome:?}"
);
}
pub(crate) async fn assert_first_range_succeeds(transfer: &DownloadTransfer) {
assert_discovery_succeeds(transfer).await;
if transfer.ctx().is_active() && transfer.ctx().metrics().network_rx == 0 {
let mut range = assert_ready(transfer.poll_work());
assert!(matches!(
range.data_mut::<DownloadWork>(),
DownloadWork::GetObjectRange { .. }
));
assert!(matches!(
execute(transfer, &mut range).await,
WorkOutcome::Success { .. }
));
}
}
pub(crate) struct ReliefScenario {
pub(crate) transfer: DownloadTransfer,
pub(crate) relief: IoRequest,
pub(crate) blocker: Reservation,
pub(crate) part_size: u64,
pub(crate) object: Arc<[u8]>,
pub(crate) path: std::path::PathBuf,
_consumer: RecvBodyConsumer,
_dir: tempfile::TempDir,
}
pub(crate) async fn relief_scenario(script: &Arc<WriteScript>) -> ReliefScenario {
let part_size = 8 * 1024 * 1024;
let object = object_bytes(2 * part_size as usize);
let pool = crate::memory::BufferPool::builder()
.memory_budget(crate::config::MemoryBudgetConfig::Limit(ByteSize::new(
(2 * part_size as usize) as u64,
)))
.build()
.expect("test pool");
let blocker = pool
.try_reserve(part_size as usize)
.unwrap()
.expect("the budget fits the blocker");
let config = crate::Config::builder()
.sdk_client(crc32_object_client(Arc::clone(&object), None))
.part_size(crate::config::PartSize::Target(ByteSize::new(part_size)))
.memory(crate::config::MemoryConfig::Explicit(pool))
.build()
.expect("valid config");
let handle = crate::client::Handle::test_handle_tokio(config);
let (transfer, consumer, dir) = disk_transfer(handle, &ScriptedSinkFactory(Arc::clone(script)));
let path = dir.path().join("out");
assert_first_range_succeeds(&transfer).await;
let mut relief = assert_ready(transfer.poll_work());
assert!(
matches!(
relief.data_mut::<DownloadWork>(),
DownloadWork::DrainResident
),
"a memory-blocked claim with a resident part schedules relief"
);
ReliefScenario {
transfer,
relief,
blocker,
part_size,
object,
path,
_consumer: consumer,
_dir: dir,
}
}
pub(crate) fn spawn_relief(
transfer: &DownloadTransfer,
mut relief: IoRequest,
) -> std::thread::JoinHandle<WorkOutcome> {
let transfer = transfer.clone();
std::thread::spawn(move || {
futures_util::FutureExt::now_or_never(transfer.execute(&mut relief))
.expect("memory relief completes without suspending")
})
}
pub(crate) fn finalize_started(events: &[Event]) -> bool {
events
.iter()
.any(|event| matches!(event, Event::Started(Op::Finalize { .. })))
}