Struct OneshotService 

pub struct OneshotService<Pr, C = HttpConnector, B = Incoming> { /* private fields */ }

Available on crate features http1 or http2 only.

A Service<Request<B>> that sends a request and returns the response, owning a Client.

let mut svc = OneshotService::http_default("example.com:1234", Static("bar")).unwrap();
let req = Request::builder()
    .uri("https://myserver.com/foo")
    .body(Empty::<Bytes>::new())
    .unwrap();
// http://example.com:1234/bar
let _res = svc.call(req).await.unwrap();

Implementations

impl<Pr, C, B> OneshotService<Pr, C, B>

pub fn from<S, A>( client: Client<C, B>, scheme: S, authority: A, path: Pr, ) -> Result<Self, HttpError>

where Scheme: TryFrom<S>, <Scheme as TryFrom<S>>::Error: Into<HttpError>, Authority: TryFrom<A>, <Authority as TryFrom<A>>::Error: Into<HttpError>,

Initializes a service with a general Client.

A client can be built by functions in client.

For the meaning of “scheme” and “authority”, refer to the documentation of Uri.

The path should implement PathRewriter.

Errors

When scheme or authority cannot be converted into a Scheme or Authority.

impl<Pr, B> OneshotService<Pr, HttpConnector, B>

where B: HttpBody + Send, B::Data: Send,

pub fn http_default<A>(authority: A, path: Pr) -> Result<Self, HttpError>

where Authority: TryFrom<A>, <Authority as TryFrom<A>>::Error: Into<HttpError>,

Use client::http_default() to build a client.

For the meaning of “authority”, refer to the documentation of Uri.

The path should implement PathRewriter.

Errors

When authority cannot be converted into an Authority.

impl<Pr, B> OneshotService<Pr, HttpsConnector<HttpConnector>, B>

where B: HttpBody + Send, B::Data: Send,

pub fn https_default<A>(authority: A, path: Pr) -> Result<Self, HttpError>

where Authority: TryFrom<A>, <Authority as TryFrom<A>>::Error: Into<HttpError>,

Available on crate features https or nativetls only.

Use client::https_default() to build a client.

This is the same as Self::nativetls_default().

For the meaning of “authority”, refer to the documentation of Uri.

The path should implement PathRewriter.

Errors

When authority cannot be converted into an Authority.

impl<Pr, B> OneshotService<Pr, HttpsConnector<HttpConnector>, B>

where B: HttpBody + Send, B::Data: Send,

pub fn nativetls_default<A>(authority: A, path: Pr) -> Result<Self, HttpError>

where Authority: TryFrom<A>, <Authority as TryFrom<A>>::Error: Into<HttpError>,

Available on crate feature nativetls only.

Use client::nativetls_default() to build a client.

For the meaning of “authority”, refer to the documentation of Uri.

The path should implement PathRewriter.

Errors

When authority cannot be converted into an Authority.

impl<Pr, B> OneshotService<Pr, RustlsConnector<HttpConnector>, B>

where B: HttpBody + Send, B::Data: Send,

pub fn https_default<A>(authority: A, path: Pr) -> Result<Self, HttpError>

where Authority: TryFrom<A>, <Authority as TryFrom<A>>::Error: Into<HttpError>,

Available on crate feature rustls only.

Use client::rustls_default() to build a client.

For the meaning of “authority”, refer to the documentation of Uri.

The path should implement PathRewriter.

Errors

When authority cannot be converted into an Authority.

Trait Implementations

impl<Pr: Clone, C: Clone, B> Clone for OneshotService<Pr, C, B>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C, B, Pr> Service<Request<B>> for OneshotService<Pr, C, B>

where C: Connect + Clone + Send + Sync + 'static, B: HttpBody + Send + 'static + Unpin, B::Data: Send, B::Error: Into<Box<dyn Error + Send + Sync>>, Pr: PathRewriter,

type Response = Result<Response<Incoming>, ProxyError>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = RevProxyFuture

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, req: Request<B>) -> Self::Future

Process the request and return the response asynchronously.