Struct HttpsConnector

pub struct HttpsConnector<T> { /* private fields */ }

Available on crate feature hyper1 only.

A Connector using BoringSSL to support http and https schemes.

Implementations

impl HttpsConnector<TokioHttpConnector>

pub fn new() -> Result<Self, ErrorStack>

Available on crate features runtime and hyper1-runtime only.

Creates a a new HttpsConnector using default settings.

The Hyper HttpConnector is used to perform the TCP socket connection. ALPN is configured to support both HTTP/2 and HTTP/1.1.

Requires the runtime Cargo feature.

impl<S, T> HttpsConnector<S>

where S: Service<Uri, Response = T> + Send, S::Error: Into<Box<dyn Error + Send + Sync>>, S::Future: Unpin + Send + 'static, T: AsyncRead + AsyncWrite + Connection + Unpin + Debug + Sync + Send + 'static,

pub fn with_connector( http: S, ssl: SslConnectorBuilder, ) -> Result<HttpsConnector<S>, ErrorStack>

Creates a new HttpsConnector.

The session cache configuration of ssl will be overwritten.

If the provided service’s response type does not fit the trait requirements because it is closer to the Hyper ecosystem than the Tokio one, wrapping your responses with TokioIo should work.

pub fn set_callback<F>(&mut self, callback: F)

where F: Fn(&mut ConnectConfiguration, &Uri) -> Result<(), ErrorStack> + 'static + Sync + Send,

Registers a callback which can customize the configuration of each connection.

Unsuitable to change verify hostflags (with config.param_mut().set_hostflags(…)), as they are reset after the callback is executed. Use Self::set_ssl_callback instead.

pub fn set_ssl_callback<F>(&mut self, callback: F)

where F: Fn(&mut SslRef, &Uri) -> Result<(), ErrorStack> + 'static + Sync + Send,

Registers a callback which can customize the Ssl of each connection.

Trait Implementations

impl<T: Clone> Clone for HttpsConnector<T>

fn clone(&self) -> HttpsConnector<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, S> Service<Uri> for HttpsConnector<S>

where S: Service<Uri, Response = T> + Send, S::Error: Into<Box<dyn Error + Send + Sync>>, S::Future: Unpin + Send + 'static, T: AsyncRead + AsyncWrite + Connection + Unpin + Debug + Sync + Send + 'static,

type Response = MaybeHttpsStream<T>

Responses given by the service.

type Error = Box<dyn Error + Sync + Send>

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<HttpsConnector<S> as Service<Uri>>::Response, <HttpsConnector<S> as Service<Uri>>::Error>> + Send>>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, uri: Uri) -> Self::Future

Process the request and return the response asynchronously.