Struct hyper::client::conn::Connection

source · [−]

pub struct Connection<T, B>where
    T: AsyncRead + AsyncWrite + Send + 'static,
    B: HttpBody + 'static,{ /* private fields */ }

Expand description

A future that processes all HTTP state for the IO object.

In most cases, this should just be spawned into an executor, so that it can process incoming and outgoing messages, notice hangups, and the like.

Implementations

source

impl<T, B> Connection<T, B>where
 T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
 B: HttpBody + Unpin + Send + 'static,
 B::Data: Send,
 B::Error: Into<Box<dyn StdError + Send + Sync>>,

source

pub fn into_parts(self) -> Parts<T>

Return the inner IO object, and additional information.

Only works for HTTP/1 connections. HTTP/2 connections will panic.

source

pub fn poll_without_shutdown(&mut self, cx: &mut Context<'_>) -> Poll<Result<()>>

Poll the connection for completion, but without calling shutdown on the underlying IO.

This is useful to allow running a connection while doing an HTTP upgrade. Once the upgrade is completed, the connection would be “done”, but it is not desired to actually shutdown the IO object. Instead you would take it back using into_parts.

Use poll_fn and try_ready! to work with this function; or use the without_shutdown wrapper.

source

pub fn without_shutdown(self) -> impl Future<Output = Result<Parts<T>>>

Prevent shutdown of the underlying IO object at the end of service the request, instead run into_parts. This is a convenience wrapper over poll_without_shutdown.

source

pub fn http2_is_extended_connect_protocol_enabled(&self) -> bool

Returns whether the extended CONNECT protocol is enabled or not.

This setting is configured by the server peer by sending the SETTINGS_ENABLE_CONNECT_PROTOCOL parameter in a SETTINGS frame. This method returns the currently acknowledged value received from the remote.

Trait Implementations

source

impl<T, B> Debug for Connection<T, B>where
T: AsyncRead + AsyncWrite + Debug + Send + 'static,
B: HttpBody + 'static,

source

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

source

impl<T, B> Future for Connection<T, B>where
 T: AsyncRead + AsyncWrite + Unpin + Send,
 B: HttpBody + Send + 'static,
 B::Data: Send,
 B::Error: Into<Box<dyn StdError + Send + Sync>>,

type Output = Result<(), Error>

The type of value produced on completion.

source

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

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

Auto Trait Implementations

impl<T, B> !RefUnwindSafe for Connection<T, B>

impl<T, B> Send for Connection<T, B>where
B: Send,
::Data: Send,

impl<T, B> Sync for Connection<T, B>where
 B: Send + Sync,
 T: Sync,
 ::Data: Send + Sync,

impl<T, B> Unpin for Connection<T, B>where
T: Unpin,

impl<T, B> !UnwindSafe for Connection<T, B>

Blanket Implementations

impl<T> Any for Twhere
T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable

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

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

const: unstable

fn from(t: T) -> T

Returns the argument unchanged.

source

impl<T> FutureExt for Twhere
T: Future + ?Sized,

source

fn map<U, F>(self, f: F) -> Map<Self, F>where
F: FnOnce(Self::Output) -> U,

Map this future’s output to a different type, returning a new future of the resulting type. Read more

source

fn map_into(self) -> MapInto<Self, U>where
Self::Output: Into,

Map this future’s output to a different type, returning a new future of the resulting type. Read more

source

fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>where
F: FnOnce(Self::Output) -> Fut,
Fut: Future,

Chain on a computation for when a future finished, passing the result of the future to the provided closure f. Read more

source

fn left_future(self) -> Either<Self, B>where
B: Future<Output = Self::Output>,

Wrap this future in an Either future, making it the left-hand variant of that Either. Read more

source

fn right_future<A>(self) -> Either<A, Self>where
A: Future<Output = Self::Output>,

Wrap this future in an Either future, making it the right-hand variant of that Either. Read more

source

fn into_stream(self) -> IntoStream<Self>

Convert this future into a single element stream. Read more

source

fn flatten(self) -> Flatten<Self>where
Self::Output: Future,

Flatten the execution of this future when the output of this future is itself another future. Read more

source

fn flatten_stream(self) -> FlattenStream<Self>where
Self::Output: Stream,

Flatten the execution of this future when the successful result of this future is a stream. Read more

source

fn fuse(self) -> Fuse<Self>

Fuse a future such that poll will never again be called once it has completed. This method can be used to turn any Future into a FusedFuture. Read more

source

fn inspect<F>(self, f: F) -> Inspect<Self, F>where
F: FnOnce(&Self::Output),

Do something with the output of a future before passing it on. Read more

source

fn catch_unwind(self) -> CatchUnwind<Self>where
Self: UnwindSafe,

Catches unwinding panics while polling the future. Read more

source

fn shared(self) -> Shared<Self>where
Self::Output: Clone,

Create a cloneable handle to this future where all handles will resolve to the same result. Read more

source

fn remote_handle(self) -> (Remote<Self>, RemoteHandle<Self::Output>)

Turn this future into a future that yields () on completion and sends its output to another future on a separate task. Read more

source

fn boxed<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + Send + 'a, Global>>where
Self: 'a + Send,

Wrap the future in a Box, pinning it. Read more

source

fn boxed_local<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'a, Global>>where
Self: 'a,

Wrap the future in a Box, pinning it. Read more

source

fn unit_error(self) -> UnitError<Self>

Turns a Future<Output = T> into a TryFuture<Ok = T, Error = ()>. Read more

source

fn never_error(self) -> NeverError<Self>

Turns a Future<Output = T> into a TryFuture<Ok = T, Error = Never>. Read more

source

fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output>where
Self: Unpin,

A convenience for calling Future::poll on Unpin future types.

source

fn now_or_never(self) -> Option<Self::Output>

Evaluates and consumes the future, returning the resulting output if the future is ready after the first call to Future::poll. Read more

source

impl<T> Instrument for T

source

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

source

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into for Twhere
U: From<T>,

const: unstable

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<F> IntoFuture for Fwhere
F: Future,

type Output = <F as Future>::Output

The output that the future will produce on completion.

type IntoFuture = F

Which kind of future are we turning this into?

fn into_future(self) -> <F as IntoFuture>::IntoFuture

Creates a future from a value. Read more

impl<T, U> TryFrom for Twhere
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

source

impl<F, T, E> TryFuture for Fwhere
F: Future<Output = Result<T, E>> + ?Sized,

type Ok = T

The type of successful values yielded by this future

type Error = E

The type of failures yielded by this future

source

fn try_poll(
self: Pin<&mut F>,
cx: &mut Context<'_>
) -> Poll<<F as Future>::Output>

Poll this TryFuture as if it were a Future. Read more

source

impl<Fut> TryFutureExt for Futwhere
Fut: TryFuture + ?Sized,

source

fn flatten_sink<Item>(self) -> FlattenSink<Self, Self::Ok>where
Self::Ok: Sink<Item, Error = Self::Error>,

Flattens the execution of this future when the successful result of this future is a Sink. Read more

source

fn map_ok<T, F>(self, f: F) -> MapOk<Self, F>where
F: FnOnce(Self::Ok) -> T,

Maps this future’s success value to a different value. Read more

source

fn map_ok_or_else<T, E, F>(self, e: E, f: F) -> MapOkOrElse<Self, F, E>where
F: FnOnce(Self::Ok) -> T,
E: FnOnce(Self::Error) -> T,

Maps this future’s success value to a different value, and permits for error handling resulting in the same type. Read more

source

fn map_err<E, F>(self, f: F) -> MapErr<Self, F>where
F: FnOnce(Self::Error) -> E,

Maps this future’s error value to a different value. Read more

source

fn err_into<E>(self) -> ErrInto<Self, E>where
Self::Error: Into<E>,

Maps this future’s Error to a new error type using the Into trait. Read more

source

fn ok_into(self) -> OkInto<Self, U>where
Self::Ok: Into,

Maps this future’s Ok to a new type using the Into trait. Read more

source

fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F>where
F: FnOnce(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,

Executes another future after this one resolves successfully. The success value is passed to a closure to create this subsequent future. Read more

source

fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F>where
F: FnOnce(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,

Executes another future if this one resolves to an error. The error value is passed to a closure to create this subsequent future. Read more

source

fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F>where
F: FnOnce(&Self::Ok),

Do something with the success value of a future before passing it on. Read more

source

fn inspect_err<F>(self, f: F) -> InspectErr<Self, F>where
F: FnOnce(&Self::Error),

Do something with the error value of a future before passing it on. Read more

source

fn try_flatten(self) -> TryFlatten<Self, Self::Ok>where
Self::Ok: TryFuture<Error = Self::Error>,

Flatten the execution of this future when the successful result of this future is another future. Read more

source

fn try_flatten_stream(self) -> TryFlattenStream<Self>where
Self::Ok: TryStream<Error = Self::Error>,

Flatten the execution of this future when the successful result of this future is a stream. Read more

source

fn unwrap_or_else<F>(self, f: F) -> UnwrapOrElse<Self, F>where
F: FnOnce(Self::Error) -> Self::Ok,

Unwraps this future’s output, producing a future with this future’s Ok type as its Output type. Read more

source

fn into_future(self) -> IntoFuture<Self>

Wraps a TryFuture into a type that implements Future. Read more

source

fn try_poll_unpin(
 &mut self,
 cx: &mut Context<'_>
) -> Poll<Result<Self::Ok, Self::Error>>where
 Self: Unpin,

A convenience method for calling TryFuture::try_poll on [Unpin] future types. Read more

impl<T, U> TryInto for Twhere
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

source

impl<T> WithSubscriber for T

source

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

source

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

Struct hyper::client::conn::Connection

Implementations

impl<T, B> Connection<T, B>where T: AsyncRead + AsyncWrite + Unpin + Send + 'static, B: HttpBody + Unpin + Send + 'static, B::Data: Send, B::Error: Into<Box<dyn StdError + Send + Sync>>,

pub fn into_parts(self) -> Parts<T>

pub fn poll_without_shutdown(&mut self, cx: &mut Context<'_>) -> Poll<Result<()>>

pub fn without_shutdown(self) -> impl Future<Output = Result<Parts<T>>>

pub fn http2_is_extended_connect_protocol_enabled(&self) -> bool

Trait Implementations

impl<T, B> Debug for Connection<T, B>where T: AsyncRead + AsyncWrite + Debug + Send + 'static, B: HttpBody + 'static,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl<T, B> Future for Connection<T, B>where T: AsyncRead + AsyncWrite + Unpin + Send, B: HttpBody + Send + 'static, B::Data: Send, B::Error: Into<Box<dyn StdError + Send + Sync>>,

type Output = Result<(), Error>

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Auto Trait Implementations

impl<T, B> !RefUnwindSafe for Connection<T, B>

impl<T, B> Send for Connection<T, B>where B: Send, <B as Body>::Data: Send,

impl<T, B> Sync for Connection<T, B>where B: Send + Sync, T: Sync, <B as Body>::Data: Send + Sync,

impl<T, B> Unpin for Connection<T, B>where T: Unpin,

impl<T, B> !UnwindSafe for Connection<T, B>

Blanket Implementations

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

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

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> FutureExt for Twhere T: Future + ?Sized,

fn map<U, F>(self, f: F) -> Map<Self, F>where F: FnOnce(Self::Output) -> U,

fn map_into<U>(self) -> MapInto<Self, U>where Self::Output: Into<U>,

fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>where F: FnOnce(Self::Output) -> Fut, Fut: Future,

fn left_future<B>(self) -> Either<Self, B>where B: Future<Output = Self::Output>,

fn right_future<A>(self) -> Either<A, Self>where A: Future<Output = Self::Output>,

fn into_stream(self) -> IntoStream<Self>

fn flatten(self) -> Flatten<Self>where Self::Output: Future,

fn flatten_stream(self) -> FlattenStream<Self>where Self::Output: Stream,

fn fuse(self) -> Fuse<Self>

fn inspect<F>(self, f: F) -> Inspect<Self, F>where F: FnOnce(&Self::Output),

fn catch_unwind(self) -> CatchUnwind<Self>where Self: UnwindSafe,

fn shared(self) -> Shared<Self>where Self::Output: Clone,

fn remote_handle(self) -> (Remote<Self>, RemoteHandle<Self::Output>)

fn boxed<'a>( self) -> Pin<Box<dyn Future<Output = Self::Output> + Send + 'a, Global>>where Self: 'a + Send,

fn boxed_local<'a>( self) -> Pin<Box<dyn Future<Output = Self::Output> + 'a, Global>>where Self: 'a,

fn unit_error(self) -> UnitError<Self>

fn never_error(self) -> NeverError<Self>

fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output>where Self: Unpin,

fn now_or_never(self) -> Option<Self::Output>

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<F> IntoFuture for Fwhere F: Future,

type Output = <F as Future>::Output

type IntoFuture = F

fn into_future(self) -> <F as IntoFuture>::IntoFuture

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<F, T, E> TryFuture for Fwhere 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 Futwhere Fut: TryFuture + ?Sized,

fn flatten_sink<Item>(self) -> FlattenSink<Self, Self::Ok>where Self::Ok: Sink<Item, Error = Self::Error>,

fn map_ok<T, F>(self, f: F) -> MapOk<Self, F>where F: FnOnce(Self::Ok) -> T,

fn map_ok_or_else<T, E, F>(self, e: E, f: F) -> MapOkOrElse<Self, F, E>where F: FnOnce(Self::Ok) -> T, E: FnOnce(Self::Error) -> T,

fn map_err<E, F>(self, f: F) -> MapErr<Self, F>where F: FnOnce(Self::Error) -> E,

fn err_into<E>(self) -> ErrInto<Self, E>where Self::Error: Into<E>,

fn ok_into<U>(self) -> OkInto<Self, U>where Self::Ok: Into<U>,

fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F>where F: FnOnce(Self::Ok) -> Fut, Fut: TryFuture<Error = Self::Error>,

fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F>where F: FnOnce(Self::Error) -> Fut, Fut: TryFuture<Ok = Self::Ok>,

fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F>where F: FnOnce(&Self::Ok),

fn inspect_err<F>(self, f: F) -> InspectErr<Self, F>where F: FnOnce(&Self::Error),

fn try_flatten(self) -> TryFlatten<Self, Self::Ok>where Self::Ok: TryFuture<Error = Self::Error>,

fn try_flatten_stream(self) -> TryFlattenStream<Self>where Self::Ok: TryStream<Error = Self::Error>,

fn unwrap_or_else<F>(self, f: F) -> UnwrapOrElse<Self, F>where F: FnOnce(Self::Error) -> Self::Ok,

fn into_future(self) -> IntoFuture<Self>

fn try_poll_unpin( &mut self, cx: &mut Context<'_>) -> Poll<Result<Self::Ok, Self::Error>>where Self: Unpin,

impl<T, B> Connection<T, B>where
T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
B: HttpBody + Unpin + Send + 'static,
B::Data: Send,
B::Error: Into<Box<dyn StdError + Send + Sync>>,

impl<T, B> Debug for Connection<T, B>where
T: AsyncRead + AsyncWrite + Debug + Send + 'static,
B: HttpBody + 'static,

impl<T, B> Future for Connection<T, B>where
T: AsyncRead + AsyncWrite + Unpin + Send,
B: HttpBody + Send + 'static,
B::Data: Send,
B::Error: Into<Box<dyn StdError + Send + Sync>>,

impl<T, B> Send for Connection<T, B>where
B: Send,
<B as Body>::Data: Send,

impl<T, B> Sync for Connection<T, B>where
B: Send + Sync,
T: Sync,
<B as Body>::Data: Send + Sync,

impl<T, B> Unpin for Connection<T, B>where
T: Unpin,

impl<T> Any for Twhere
T: 'static + ?Sized,

impl<T> Borrow<T> for Twhere
T: ?Sized,

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

impl<T> FutureExt for Twhere
T: Future + ?Sized,

fn map<U, F>(self, f: F) -> Map<Self, F>where
F: FnOnce(Self::Output) -> U,

fn map_into<U>(self) -> MapInto<Self, U>where
Self::Output: Into<U>,

fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>where
F: FnOnce(Self::Output) -> Fut,
Fut: Future,

fn left_future<B>(self) -> Either<Self, B>where
B: Future<Output = Self::Output>,

fn right_future<A>(self) -> Either<A, Self>where
A: Future<Output = Self::Output>,

fn flatten(self) -> Flatten<Self>where
Self::Output: Future,

fn flatten_stream(self) -> FlattenStream<Self>where
Self::Output: Stream,

fn inspect<F>(self, f: F) -> Inspect<Self, F>where
F: FnOnce(&Self::Output),

fn catch_unwind(self) -> CatchUnwind<Self>where
Self: UnwindSafe,

fn shared(self) -> Shared<Self>where
Self::Output: Clone,

fn boxed<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + Send + 'a, Global>>where
Self: 'a + Send,

fn boxed_local<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'a, Global>>where
Self: 'a,

fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output>where
Self: Unpin,

impl<T, U> Into<U> for Twhere
U: From<T>,

impl<F> IntoFuture for Fwhere
F: Future,

impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

impl<F, T, E> TryFuture for Fwhere
F: Future<Output = Result<T, E>> + ?Sized,

fn try_poll(
self: Pin<&mut F>,
cx: &mut Context<'_>
) -> Poll<<F as Future>::Output>

impl<Fut> TryFutureExt for Futwhere
Fut: TryFuture + ?Sized,

fn flatten_sink<Item>(self) -> FlattenSink<Self, Self::Ok>where
Self::Ok: Sink<Item, Error = Self::Error>,

fn map_ok<T, F>(self, f: F) -> MapOk<Self, F>where
F: FnOnce(Self::Ok) -> T,

fn map_ok_or_else<T, E, F>(self, e: E, f: F) -> MapOkOrElse<Self, F, E>where
F: FnOnce(Self::Ok) -> T,
E: FnOnce(Self::Error) -> T,

fn map_err<E, F>(self, f: F) -> MapErr<Self, F>where
F: FnOnce(Self::Error) -> E,

fn err_into<E>(self) -> ErrInto<Self, E>where
Self::Error: Into<E>,

fn ok_into<U>(self) -> OkInto<Self, U>where
Self::Ok: Into<U>,

fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F>where
F: FnOnce(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,

fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F>where
F: FnOnce(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,

fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F>where
F: FnOnce(&Self::Ok),

fn inspect_err<F>(self, f: F) -> InspectErr<Self, F>where
F: FnOnce(&Self::Error),

fn try_flatten(self) -> TryFlatten<Self, Self::Ok>where
Self::Ok: TryFuture<Error = Self::Error>,

fn try_flatten_stream(self) -> TryFlattenStream<Self>where
Self::Ok: TryStream<Error = Self::Error>,

fn unwrap_or_else<F>(self, f: F) -> UnwrapOrElse<Self, F>where
F: FnOnce(Self::Error) -> Self::Ok,

fn try_poll_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<Self::Ok, Self::Error>>where
Self: Unpin,

impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
S: Into<Dispatch>,