| //! Middleware that applies a timeout to requests. |
| //! |
| //! If the response does not complete within the specified timeout, the response |
| //! will be aborted. |
| |
| pub mod error; |
| pub mod future; |
| mod layer; |
| |
| pub use self::layer::TimeoutLayer; |
| |
| use self::future::ResponseFuture; |
| use std::task::{Context, Poll}; |
| use std::time::Duration; |
| use tower_service::Service; |
| |
| /// Applies a timeout to requests. |
| #[derive(Debug, Clone)] |
| pub struct Timeout<T> { |
| inner: T, |
| timeout: Duration, |
| } |
| |
| // ===== impl Timeout ===== |
| |
| impl<T> Timeout<T> { |
| /// Creates a new [`Timeout`] |
| pub fn new(inner: T, timeout: Duration) -> Self { |
| Timeout { inner, timeout } |
| } |
| |
| /// Get a reference to the inner service |
| pub fn get_ref(&self) -> &T { |
| &self.inner |
| } |
| |
| /// Get a mutable reference to the inner service |
| pub fn get_mut(&mut self) -> &mut T { |
| &mut self.inner |
| } |
| |
| /// Consume `self`, returning the inner service |
| pub fn into_inner(self) -> T { |
| self.inner |
| } |
| } |
| |
| impl<S, Request> Service<Request> for Timeout<S> |
| where |
| S: Service<Request>, |
| S::Error: Into<crate::BoxError>, |
| { |
| type Response = S::Response; |
| type Error = crate::BoxError; |
| type Future = ResponseFuture<S::Future>; |
| |
| fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { |
| match self.inner.poll_ready(cx) { |
| Poll::Pending => Poll::Pending, |
| Poll::Ready(r) => Poll::Ready(r.map_err(Into::into)), |
| } |
| } |
| |
| fn call(&mut self, request: Request) -> Self::Future { |
| let response = self.inner.call(request); |
| let sleep = tokio::time::sleep(self.timeout); |
| |
| ResponseFuture::new(response, sleep) |
| } |
| } |