use crate::error::{self, ErrorKind};
use crate::operation::download::body::{Body, RecvBodyConsumer};
use crate::operation::download::output::DownloadOutput;
use crate::operation::download::transfer::DownloadTransfer;
use crate::operation::download::ObjectMetadata;
use crate::transfer::{StateMachineTerminalReceiver, TransferId};
#[derive(Debug)]
pub(crate) struct DownloadHandleInner {
pub(crate) transfer: DownloadTransfer,
pub(crate) completion_rx: Option<StateMachineTerminalReceiver>,
}
impl DownloadHandleInner {
pub(crate) async fn object_meta(&self) -> Result<&ObjectMetadata, error::Error> {
if let Some(meta) = self.transfer.object_meta() {
return Ok(meta);
}
let notified = self.transfer.discovery_notify().notified();
if let Some(meta) = self.transfer.object_meta() {
return Ok(meta);
}
if self.transfer.ctx().is_active() {
notified.await;
}
self.transfer.object_meta().ok_or_else(|| {
if self.transfer.ctx().is_cancelled() {
error::from_kind(ErrorKind::OperationCancelled)("download cancelled")
} else {
error::from_kind(ErrorKind::ObjectNotDiscoverable)("discovery failed")
}
})
}
pub(crate) async fn join(&mut self) -> Result<DownloadOutput, error::Error> {
if let Some(rx) = self.completion_rx.take() {
let _ = rx.await;
}
let ctx = self.transfer.ctx();
let id = self.transfer.id();
if ctx.is_failed() {
tracing::debug!(
target: crate::telemetry::TARGET_TRANSFER_DOWNLOAD,
tid = %ctx.id,
"join: cancelling and waiting for idle",
);
ctx.handle
.scheduler
.cancel_transfer(id)
.wait_for_idle()
.await;
tracing::debug!(
target: crate::telemetry::TARGET_TRANSFER_DOWNLOAD,
tid = %ctx.id,
"join: idle, returning error",
);
let err = ctx.take_error().expect("error taken outside of join()");
return Err(err);
}
if ctx.is_cancelled() {
return Err(error::Error::new(
error::ErrorKind::OperationCancelled,
"download cancelled",
));
}
let object_meta = self
.transfer
.object_meta()
.expect("object_meta must be set on successful completion")
.clone();
let integrity_checks = self
.transfer
.integrity_checks()
.expect("integrity_checks must be set on successful completion")
.clone();
Ok(DownloadOutput::new(
object_meta,
ctx.metrics(),
integrity_checks,
))
}
pub(crate) async fn abort(&self) {
let ctx = self.transfer.ctx();
let id = self.transfer.id();
ctx.set_cancelled();
self.transfer.writer().notify_consumer();
ctx.handle
.scheduler
.cancel_transfer(id)
.wait_for_idle()
.await;
}
pub(crate) fn scheduling(&self) -> crate::transfer::SchedulingCtl<'_> {
self.transfer.ctx().scheduling()
}
pub(crate) fn io_ctl(&self) -> DownloadIoCtl<'_> {
DownloadIoCtl {
transfer: &self.transfer,
}
}
}
#[derive(Debug)]
pub struct DownloadIoCtl<'a> {
transfer: &'a DownloadTransfer,
}
impl<'a> DownloadIoCtl<'a> {
pub fn set_read_ahead(&self, mode: crate::config::ReadAhead) {
self.transfer.set_read_ahead(&mode);
}
#[cfg(test)]
pub(crate) fn for_test(transfer: &'a DownloadTransfer) -> Self {
Self { transfer }
}
}
#[derive(Debug)]
#[non_exhaustive]
pub struct DownloadHandle {
pub(crate) inner: DownloadHandleInner,
pub(crate) body: Body,
}
impl DownloadHandle {
pub(crate) fn new(
transfer: DownloadTransfer,
consumer: RecvBodyConsumer,
completion_rx: StateMachineTerminalReceiver,
) -> Self {
let body = Body::new(consumer, transfer.clone());
Self {
inner: DownloadHandleInner {
transfer,
completion_rx: Some(completion_rx),
},
body,
}
}
pub async fn object_meta(&self) -> Result<&ObjectMetadata, error::Error> {
self.inner.object_meta().await
}
pub fn body(&self) -> &Body {
&self.body
}
pub fn body_mut(&mut self) -> &mut Body {
&mut self.body
}
pub async fn join(mut self) -> Result<DownloadOutput, error::Error> {
self.body.close();
self.inner.join().await
}
pub async fn abort(mut self) {
self.body.close();
self.inner.abort().await;
}
pub fn scheduling(&self) -> crate::transfer::SchedulingCtl<'_> {
self.inner.scheduling()
}
pub fn io_ctl(&self) -> crate::operation::download::DownloadIoCtl<'_> {
self.inner.io_ctl()
}
pub fn status(&self) -> crate::types::TransferStatus {
self.inner.transfer.ctx().transfer_status()
}
pub fn metrics(&self) -> crate::metrics::TransferMetrics {
self.inner.transfer.ctx().metrics()
}
}
impl Drop for DownloadHandle {
fn drop(&mut self) {
let ctx = self.inner.transfer.ctx();
if ctx.is_active() {
ctx.set_cancelled();
self.inner.transfer.writer().notify_consumer();
ctx.handle
.scheduler
.cancel_transfer(self.inner.transfer.id());
}
}
}
#[derive(Debug)]
pub struct ManagedDownloadHandle {
inner: DownloadHandleInner,
temp_path: Option<std::path::PathBuf>,
dest_path: Option<std::path::PathBuf>,
}
impl ManagedDownloadHandle {
pub(crate) fn new(
inner: DownloadHandleInner,
temp_path: std::path::PathBuf,
dest_path: std::path::PathBuf,
) -> Self {
Self {
inner,
temp_path: Some(temp_path),
dest_path: Some(dest_path),
}
}
#[cfg(any(unix, windows, target_os = "wasi"))]
pub(crate) fn new_unmanaged(inner: DownloadHandleInner) -> Self {
Self {
inner,
temp_path: None,
dest_path: None,
}
}
pub(crate) fn transfer_id(&self) -> TransferId {
self.inner.transfer.id()
}
pub async fn object_meta(&self) -> Result<&ObjectMetadata, error::Error> {
self.inner.object_meta().await
}
pub async fn join(
mut self,
) -> Result<crate::operation::download::output::DownloadOutput, error::Error> {
let result = self.inner.join().await;
match &result {
Ok(_) => self.finalize().await?,
Err(_) => {
self.cleanup().await;
}
}
result
}
pub async fn abort(mut self) {
self.inner.abort().await;
self.cleanup().await;
}
pub fn scheduling(&self) -> crate::transfer::SchedulingCtl<'_> {
self.inner.scheduling()
}
pub fn io_ctl(&self) -> crate::operation::download::DownloadIoCtl<'_> {
self.inner.io_ctl()
}
pub fn status(&self) -> crate::types::TransferStatus {
self.inner.transfer.ctx().transfer_status()
}
pub fn metrics(&self) -> crate::metrics::TransferMetrics {
self.inner.transfer.ctx().metrics()
}
async fn finalize(&mut self) -> Result<(), error::Error> {
if let (Some(temp), Some(dest)) = (self.temp_path.take(), &self.dest_path) {
if let Err(e) = crate::io::fs::rename_async(&temp, dest).await {
let _ = crate::io::fs::remove_file_async(&temp).await;
return Err(error::io_at("renaming temporary file to", dest, e));
}
}
Ok(())
}
async fn cleanup(&mut self) {
if let Some(temp) = self.temp_path.take() {
let _ = crate::io::fs::remove_file_async(&temp).await;
}
}
}
impl Drop for ManagedDownloadHandle {
fn drop(&mut self) {
let ctx = self.inner.transfer.ctx();
if ctx.is_active() {
ctx.set_cancelled();
self.inner.transfer.writer().notify_consumer();
ctx.handle
.scheduler
.cancel_transfer(self.inner.transfer.id());
}
if let Some(temp) = &self.temp_path {
let _ = std::fs::remove_file(temp);
}
}
}
#[cfg(test)]
mod tests {
use super::{DownloadHandle, DownloadHandleInner, ManagedDownloadHandle};
use crate::error::ErrorKind;
use crate::operation::download::body::{new_recv_body, RecvBodyConsumer};
use crate::operation::download::transfer::DownloadTransfer;
use crate::operation::download::DownloadInput;
use crate::transfer::TransferContext;
use crate::types::BucketType;
fn is_send<T: Send>() {}
fn is_sync<T: Sync>() {}
#[test]
fn test_handle_properties() {
is_send::<DownloadHandle>();
is_sync::<DownloadHandle>();
is_send::<ManagedDownloadHandle>();
is_sync::<ManagedDownloadHandle>();
}
fn make_cancelled_download_inner() -> (DownloadHandleInner, RecvBodyConsumer) {
let handle = crate::client::Handle::test_handle_tokio(
crate::Config::builder()
.sdk_client(aws_smithy_mocks::mock_client!(
aws_sdk_s3,
aws_smithy_mocks::RuleMode::MatchAny,
&[]
))
.build()
.expect("valid config"),
);
let input = DownloadInput::builder()
.bucket("test-bucket")
.key("test-key")
.build()
.unwrap();
let (writer, consumer) = new_recv_body();
let (ctx, completion_rx) = TransferContext::new(handle);
let transfer = DownloadTransfer::new(ctx.clone(), BucketType::Standard, input, writer);
ctx.set_cancelled();
ctx.signal_terminal();
let inner = DownloadHandleInner {
transfer,
completion_rx: Some(completion_rx),
};
(inner, consumer)
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_download_join_returns_cancelled_error_when_transfer_cancelled() {
let (inner, consumer) = make_cancelled_download_inner();
let body = super::Body::new(consumer, inner.transfer.clone());
let handle = DownloadHandle { inner, body };
let err = handle
.join()
.await
.expect_err("join on cancelled transfer must return Err");
assert_eq!(err.kind(), &ErrorKind::OperationCancelled);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_managed_download_join_returns_cancelled_and_cleans_up() {
let dir = tempfile::tempdir().unwrap();
let dest = dir.path().join("out.dat");
let temp = dir.path().join("out.dat.s3tmp.abcdefgh");
std::fs::write(&temp, b"partial").unwrap();
let (inner, _consumer) = make_cancelled_download_inner();
let managed = ManagedDownloadHandle::new(inner, temp.clone(), dest.clone());
let err = managed
.join()
.await
.expect_err("join on cancelled transfer must return Err");
assert_eq!(err.kind(), &ErrorKind::OperationCancelled);
assert!(
!temp.exists(),
"temp file must be cleaned up on cancellation"
);
assert!(
!dest.exists(),
"dest file must not be created on cancellation"
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_managed_download_drop_after_rename_keeps_file_at_temp_path() {
let dir = tempfile::tempdir().unwrap();
let dest = dir.path().join("out.dat");
let temp = dir.path().join("out.dat.s3tmp.0000abcd");
std::fs::write(&temp, b"object").unwrap();
let (inner, _consumer) = make_cancelled_download_inner();
let mut managed = ManagedDownloadHandle::new(inner, temp.clone(), dest.clone());
managed.finalize().await.unwrap();
assert_eq!(std::fs::read(&dest).unwrap(), b"object");
std::fs::write(&temp, b"another download").unwrap();
drop(managed);
assert_eq!(std::fs::read(&temp).unwrap(), b"another download");
assert_eq!(std::fs::read(&dest).unwrap(), b"object");
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_managed_download_drop_after_cleanup_keeps_file_at_temp_path() {
let dir = tempfile::tempdir().unwrap();
let dest = dir.path().join("out.dat");
let temp = dir.path().join("out.dat.s3tmp.0000abcd");
std::fs::write(&temp, b"partial").unwrap();
let (inner, _consumer) = make_cancelled_download_inner();
let mut managed = ManagedDownloadHandle::new(inner, temp.clone(), dest.clone());
managed.cleanup().await;
assert!(!temp.exists(), "cleanup must remove the temp file");
std::fs::write(&temp, b"another download").unwrap();
drop(managed);
assert_eq!(std::fs::read(&temp).unwrap(), b"another download");
assert!(!dest.exists(), "cleanup must not create the destination");
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_managed_download_failed_rename_removes_temp_file_once() {
let dir = tempfile::tempdir().unwrap();
let dest = dir.path().join("missing").join("out.dat");
let temp = dir.path().join("out.dat.s3tmp.0000abcd");
std::fs::write(&temp, b"object").unwrap();
let (inner, _consumer) = make_cancelled_download_inner();
let mut managed = ManagedDownloadHandle::new(inner, temp.clone(), dest.clone());
let err = managed
.finalize()
.await
.expect_err("renaming into a missing directory must fail");
assert_eq!(err.kind(), &ErrorKind::IOError);
assert_eq!(
err.to_string(),
format!(
"I/O error renaming temporary file to \"{}\"",
dest.display()
)
);
let source = std::error::Error::source(&err)
.and_then(|s| s.downcast_ref::<std::io::Error>())
.expect("the rename's error is the source");
assert_eq!(source.kind(), std::io::ErrorKind::NotFound);
assert!(!temp.exists(), "a failed rename must remove the temp file");
assert!(
!dest.exists(),
"a failed rename must not create the destination"
);
std::fs::write(&temp, b"another download").unwrap();
drop(managed);
assert_eq!(std::fs::read(&temp).unwrap(), b"another download");
}
}