Is cancellation supported?

[thomas001]

Currently, I know of 2 ways of how to "cancel" a future:

1. Just stop polling it and eventually drop it.

   This is the easiest one, if you never poll a future again it won't make progress. This is how https://docs.rs/tokio/latest/tokio/time/fn.timeout.html works for example. If the timeout expires the underlying future is just dropped.

   The downside of that approach is that the future might not expect being dropped. Assume that the future is stopped in the middle of reading a huge chunk of data from a socket. The next code that tries to read data from the same socket will receive the remaining parts of the data, which is most likely just garbage to that code.

   Tokio calls this "cancellation safety". It also allows to use the future safely in tokio::select!. For example in tokio::io::AsyncWriteExt, write is cancellation safe while write_all is not.

2. Using explicit cancellation using CancellationToken. There are several crates providing this functionality. For example tokio_util::sync::CancellationToken (docs). Basically this is explicit cancellation where the future needs to explicitly poll the cancellation state. The advantage is that the future can control at which points it can be cancelled and at which points it cannot. It also allows cleanup work after cancellation.

Unfortunately, It doesn't seem like the AWS SDK support either of those options. Is there anything I am missing or is there no way to cancel a request?

[rcoh]

I expect that if you drop a future from the Rust SDK, it will bubble down to Hyper and cancel the request, but I have admittedly not personally verified that.