use crate::error::{Error, ErrorKind};
use crate::operation::upload::transfer::{UploadResult, UploadTransfer};
use crate::operation::upload::UploadOutput;
use crate::transfer::StateMachineTerminalReceiver;
use crate::types::{AbortOutcome, AbortedUpload};
#[derive(Debug)]
#[non_exhaustive]
pub struct UploadHandle {
completion_rx: Option<StateMachineTerminalReceiver>,
transfer: UploadTransfer,
}
impl UploadHandle {
pub(crate) fn new(
completion_rx: StateMachineTerminalReceiver,
transfer: UploadTransfer,
) -> Self {
Self {
completion_rx: Some(completion_rx),
transfer,
}
}
pub async fn join(mut self) -> Result<UploadOutput, Error> {
if let Some(rx) = self.completion_rx.take() {
let _ = rx.await;
}
let ctx = self.transfer.ctx();
if ctx.is_failed() {
ctx.handle
.scheduler
.cancel_transfer(ctx.id)
.wait_for_idle()
.await;
let err = ctx.take_error().expect("failed transfer must have error");
return Err(err);
}
if ctx.is_cancelled() {
return Err(Error::new(
ErrorKind::OperationCancelled,
"upload cancelled",
));
}
match self.transfer.take_result() {
Some(UploadResult::Completed(output)) => Ok(output),
other => unreachable!("result must be set on successful completion instead {other:?}"),
}
}
pub async fn abort(mut self) -> Result<AbortedUpload, Error> {
self.transfer.request_abort();
if let Some(rx) = self.completion_rx.take() {
let _ = rx.await;
}
let ctx = self.transfer.ctx();
if ctx.is_failed() {
return Err(ctx.take_error().expect("failed transfer must have error"));
}
Ok(match self.transfer.take_result() {
Some(UploadResult::Completed(output)) => AbortedUpload {
outcome: AbortOutcome::AlreadyCompleted,
output: Some(output),
..Default::default()
},
Some(UploadResult::Aborted(aborted)) => aborted,
None => AbortedUpload {
outcome: AbortOutcome::Cancelled,
..Default::default()
},
})
}
pub(crate) fn id(&self) -> crate::transfer::TransferId {
self.transfer.ctx().id
}
pub fn scheduling(&self) -> crate::transfer::SchedulingCtl<'_> {
self.transfer.ctx().scheduling()
}
pub fn status(&self) -> crate::types::TransferStatus {
self.transfer.ctx().transfer_status()
}
pub fn metrics(&self) -> crate::metrics::TransferMetrics {
self.transfer.ctx().metrics()
}
}
impl Drop for UploadHandle {
fn drop(&mut self) {
let ctx = self.transfer.ctx();
if ctx.is_active() {
ctx.set_cancelled();
ctx.handle.scheduler.cancel_transfer(ctx.id);
}
}
}
#[cfg(test)]
mod tests {
use super::UploadHandle;
use crate::error::ErrorKind;
use crate::io::InputStream;
use crate::operation::upload::transfer::UploadTransfer;
use crate::operation::upload::UploadInput;
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::<UploadHandle>();
is_sync::<UploadHandle>();
}
#[cfg_attr(miri, ignore)]
#[tokio::test]
async fn test_join_returns_cancelled_error_when_transfer_cancelled() {
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 mut input = UploadInput::builder()
.bucket("test-bucket")
.key("test-key")
.body(InputStream::from(Vec::<u8>::new()))
.build()
.unwrap();
let stream = input.take_body();
let (ctx, completion_rx) = TransferContext::new(handle);
let transfer =
UploadTransfer::try_new(ctx.clone(), BucketType::Standard, input, stream).unwrap();
ctx.set_cancelled();
ctx.signal_terminal();
let upload_handle = UploadHandle::new(completion_rx, transfer);
let err = upload_handle
.join()
.await
.expect_err("join on cancelled transfer must return Err");
assert_eq!(err.kind(), &ErrorKind::OperationCancelled);
}
}