Struct UpgradeableConnection 

pub struct UpgradeableConnection<'a, I, S>
where
    S: Service<Request<Incoming>, Output = Response, Error = !>,
{ /* private fields */ }

Available on crate features http-backend and http and std only.

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> UpgradeableConnection<'_, I, S>

where S: Service<Request<Incoming>, Output = Response, Error = !> + Clone, I: AsyncRead + AsyncWrite + Send + Unpin + ExtensionsRef + 'static,

pub fn with_upgrade_guard<G>(self, guard: G) -> UpgradeableConnection<'_, I, S>

where G: Send + Sync + 'static,

Bind guard to the transport an HTTP/1 upgrade hands out, so it is released when the upgraded connection closes; otherwise it is dropped with this connection.

An HTTP/2 connection drops it at protocol detection: its upgraded streams live within the connection itself.

pub fn graceful_shutdown(self: Pin<&mut UpgradeableConnection<'_, I, S>>)

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.

pub fn into_owned(self) -> UpgradeableConnection<'static, I, S>

where Builder: Clone,

Make this Connection static, instead of borrowing from Builder.

Trait Implementations

impl<I, S> Future for UpgradeableConnection<'_, I, S>

where S: Service<Request<Incoming>, Output = Response, Error = !> + Clone, I: AsyncRead + AsyncWrite + Send + Unpin + ExtensionsRef + 'static,

type Output = Result<(), Box<dyn Error + Sync + Send>>

The type of value produced on completion.

fn poll( self: Pin<&mut UpgradeableConnection<'_, I, S>>, cx: &mut Context<'_>, ) -> Poll<<UpgradeableConnection<'_, I, S> as Future>::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<'__pin, 'a, I, S> Unpin for UpgradeableConnection<'a, I, S>

where <PinnedFieldsOfHelperStruct<__Origin<'__pin, 'a, I, S>> as PinnedFieldsOfHelperTrait>::Actual: Unpin, S: Service<Request<Incoming>, Output = Response, Error = !>,