Struct tower_hyper::Connect

pub struct Connect<A, B, C, E> { /* fields omitted */ }

Creates a hyper connection

This accepts a hyper::client::conn::Builder and provides a MakeService implementation to create connections from some target A

Methods

impl<A, B, C> Connect<A, B, C, DefaultExecutor> where
    C: HttpMakeConnection<A>,
    B: HttpBody,
    C::Connection: Send + 'static, 

pub fn new(inner: C) -> Self

Create a new Connect.

The C argument is used to obtain new session layer instances (AsyncRead + AsyncWrite). For each new client service returned, a Service is returned that can be driven by poll_service and to send requests via call.

pub fn with_builder(inner: C, builder: Builder) -> Self

Create a new Connect with a builder.

impl<A, B, C, E> Connect<A, B, C, E> where
    C: HttpMakeConnection<A>,
    B: HttpBody,
    C::Connection: Send + 'static, 

pub fn with_executor(inner: C, builder: Builder, exec: E) -> Self

Create a new Connect.

The C argument is used to obtain new session layer instances (AsyncRead + AsyncWrite). For each new client service returned, a Service is returned that can be driven by poll_service and to send requests via call.

The E argument is the executor that the background task for the connection will be spawned on.

Trait Implementations

impl<A: Debug, B: Debug, C: Debug, E: Debug> Debug for Connect<A, B, C, E>

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

Formats the value using the given formatter.

impl<A, B, C, E> Service<A> for Connect<A, B, C, E> where
    C: HttpMakeConnection<A> + 'static,
    B: HttpBody + Send + 'static,
    B::Data: Send,
    B::Error: Into<Box<dyn Error + Send + Sync>>,
    C::Connection: Send + 'static,
    E: ConnectExecutor<C::Connection, B> + Clone, 

type Response = Connection<B>

Responses given by the service.

type Error = ConnectError<C::Error>

Errors produced by the service.

type Future = ConnectFuture<A, B, C, E>

The future response value.

fn poll_ready(&mut self) -> Poll<(), Self::Error>

Check if the MakeConnection is ready for a new connection.

fn call(&mut self, target: A) -> Self::Future

Obtains a Connection on a single plaintext h2 connection to a remote.