mirror of
https://github.com/tokio-rs/tokio.git
synced 2025-09-28 12:10:37 +00:00
8bf2e9aeb0
This patch introduces `Timeout`. This new type allows setting a timeout both using a duration and an instant. Given this overlap with `Deadline`, `Deadline` is deprecated. In addition to supporting future timeouts, the `Timeout` combinator is able to provide timeout functionality to streams. It does this by applying a duration based timeout to each item being yielded. The main reason for introducing `Timeout` is that a deadline approach does not work with streams. Since `Timeout` needed to be introduced anyway, keeping `Deadline` around does not make sense.
72 lines
2.0 KiB
Rust
72 lines
2.0 KiB
Rust
#[allow(deprecated)]
|
|
use tokio_timer::Deadline;
|
|
use tokio_timer::Timeout;
|
|
|
|
use futures::Future;
|
|
|
|
use std::time::{Instant, Duration};
|
|
|
|
|
|
/// An extension trait for `Future` that provides a variety of convenient
|
|
/// combinator functions.
|
|
///
|
|
/// Currently, there only is a [`timeout`] function, but this will increase
|
|
/// over time.
|
|
///
|
|
/// Users are not expected to implement this trait. All types that implement
|
|
/// `Future` already implement `FutureExt`.
|
|
///
|
|
/// This trait can be imported directly or via the Tokio prelude: `use
|
|
/// tokio::prelude::*`.
|
|
///
|
|
/// [`timeout`]: #method.timeout
|
|
pub trait FutureExt: Future {
|
|
|
|
/// Creates a new future which allows `self` until `timeout`.
|
|
///
|
|
/// This combinator creates a new future which wraps the receiving future
|
|
/// with a timeout. The returned future is allowed to execute until it
|
|
/// completes or `timeout` has elapsed, whichever happens first.
|
|
///
|
|
/// If the future completes before `timeout` then the future will resolve
|
|
/// with that item. Otherwise the future will resolve to an error.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # extern crate tokio;
|
|
/// # extern crate futures;
|
|
/// use tokio::prelude::*;
|
|
/// use std::time::Duration;
|
|
/// # use futures::future::{self, FutureResult};
|
|
///
|
|
/// # fn long_future() -> FutureResult<(), ()> {
|
|
/// # future::ok(())
|
|
/// # }
|
|
/// #
|
|
/// # fn main() {
|
|
/// let future = long_future()
|
|
/// .timeout(Duration::from_secs(1))
|
|
/// .map_err(|e| println!("error = {:?}", e));
|
|
///
|
|
/// tokio::run(future);
|
|
/// # }
|
|
/// ```
|
|
fn timeout(self, timeout: Duration) -> Timeout<Self>
|
|
where Self: Sized,
|
|
{
|
|
Timeout::new(self, timeout)
|
|
}
|
|
|
|
#[deprecated(since = "0.1.8", note = "use `timeout` instead")]
|
|
#[allow(deprecated)]
|
|
#[doc(hidden)]
|
|
fn deadline(self, deadline: Instant) -> Deadline<Self>
|
|
where Self: Sized,
|
|
{
|
|
Deadline::new(self, deadline)
|
|
}
|
|
}
|
|
|
|
impl<T: ?Sized> FutureExt for T where T: Future {}
|