Struct UpgradeableConnection

#[must_use = "futures do nothing unless polled"]
pub struct UpgradeableConnection<'a, I, S, E>
where
    S: HttpService<Incoming>, { /* private fields */ }

An upgradable Connection, returned by Builder::serve_upgradable_connection.

To drive HTTP on this connection this future must be polled, typically with .await. If it isn't polled, no progress will be made on this connection.

Implementations

impl<I, S, E, B> UpgradeableConnection<'_, I, S, E> where S: HttpService<Incoming, ResBody = B>, S::Error: Into<Box<dyn StdError + Send + Sync>>, I: Read + Write + Unpin, B: Body + 'static, B::Error: Into<Box<dyn StdError + Send + Sync>>, E: HttpServerConnExec<S::Future, B>,

fn graceful_shutdown(self: Pin<&mut Self>)

Start a graceful shutdown process for this connection.

This UpgradeableConnection should continue to be polled until shutdown can finish.

Note

This should only be called while the Connection future is still nothing. pending. If called after UpgradeableConnection::poll has resolved, this does nothing.

fn into_owned(self) -> UpgradeableConnection<'static, I, S, E>
where
    Builder<E>: Clone,

Make this Connection static, instead of borrowing from Builder.

Trait Implementations

impl<'__pin, 'a, I, S, E> Unpin for UpgradeableConnection<'a, I, S, E> where PinnedFieldsOf<__Origin<'__pin, 'a, I, S, E>>: Unpin, S: HttpService<Incoming>,

impl<I, S, E, B> Future for UpgradeableConnection<'_, I, S, E> where S: Service<Request<Incoming>, Response = Response<B>>, S::Future: 'static, S::Error: Into<Box<dyn StdError + Send + Sync>>, B: Body + 'static, B::Error: Into<Box<dyn StdError + Send + Sync>>, I: Read + Write + Unpin + Send + 'static, E: HttpServerConnExec<S::Future, B>,

type Output = Result<(), Box<dyn Error + Sync + Send>>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Auto Trait Implementations

impl<'a, I, S, E> !Freeze for UpgradeableConnection<'a, I, S, E>

impl<'a, I, S, E> !RefUnwindSafe for UpgradeableConnection<'a, I, S, E>

impl<'a, I, S, E> !UnsafeUnpin for UpgradeableConnection<'a, I, S, E>

impl<'a, I, S, E> !UnwindSafe for UpgradeableConnection<'a, I, S, E>

impl<'a, I, S, E> Send for UpgradeableConnection<'a, I, S, E> where UpgradeableConnState<'a, I, S, E>: Send,

impl<'a, I, S, E> Sync for UpgradeableConnection<'a, I, S, E> where UpgradeableConnState<'a, I, S, E>: Sync,

Blanket Implementations

impl<F> IntoFuture for UpgradeableConnection<'a, I, S, E> where F: Future,

type Output = <F as Future>::Output;
type IntoFuture = F;
fn into_future(self) -> <F as IntoFuture>::IntoFuture

impl<F, T, E> TryFuture for UpgradeableConnection<'a, I, S, E> where F: Future<Output = Result<T, E>> + ?Sized,

type Ok = T;
type Error = E;
fn try_poll(self: Pin<&mut F>, cx: &mut Context<'_>) -> Poll<<F as Future>::Output>

impl<Fut> TryFutureExt for UpgradeableConnection<'a, I, S, E> where Fut: TryFuture + ?Sized,

impl<T> Any for UpgradeableConnection<'a, I, S, E> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for UpgradeableConnection<'a, I, S, E> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for UpgradeableConnection<'a, I, S, E> where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for UpgradeableConnection<'a, I, S, E>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> FutureExt for UpgradeableConnection<'a, I, S, E> where T: Future + ?Sized,

impl<T> FutureExt for UpgradeableConnection<'a, I, S, E> where T: Future + ?Sized,

impl<T> Instrument for UpgradeableConnection<'a, I, S, E>

impl<T> WithSubscriber for UpgradeableConnection<'a, I, S, E>

impl<T, U> Into<U> for UpgradeableConnection<'a, I, S, E> where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for UpgradeableConnection<'a, I, S, E> where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for UpgradeableConnection<'a, I, S, E> where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>