Struct Proxy

pub struct Proxy { /* private fields */ }

Implementations

impl Proxy

pub fn new(peer: HttpPeer) -> Self

pub fn new_custom(peer_resolver: Rc<dyn HttpPeerResolve>) -> Self

pub fn guard<G: Guard + 'static>(self, guard: G) -> Self

Adds a routing guard.

Use this to allow multiple chained file services that respond to strictly different properties of a request. Due to the way routing works, if a guard check returns true and the request starts being handled by the file service, it will not be able to back-out and try the next service, you will simply get a 404 (or 405) error response.

pub fn default_handler<F, U>(self, f: F) -> Self

where F: IntoServiceFactory<U, ServiceRequest>, U: ServiceFactory<ServiceRequest, Config = (), Response = ServiceResponse, Error = Error> + 'static,

Sets default handler which is used when no peer could be found.

pub fn error_handler<F, U>(self, f: F) -> Self

where F: IntoServiceFactory<U, ProxyError>, U: ServiceFactory<ProxyError, Config = (), Response = HttpResponse, Error = Error> + 'static,

Trait Implementations

impl HttpServiceFactory for Proxy

fn register(self, config: &mut AppService)

impl ServiceFactory<ServiceRequest> for Proxy

type Response = ServiceResponse

Responses given by the created services.

type Error = Error

Errors produced by the created services.

type Config = ()

Service factory configuration.

type Service = ProxyService

The kind of Service created by this factory.

type InitError = ()

Errors potentially raised while building a service.

type Future = Pin<Box<dyn Future<Output = Result<<Proxy as ServiceFactory<ServiceRequest>>::Service, <Proxy as ServiceFactory<ServiceRequest>>::InitError>>>>

The future of the Service instance.g

fn new_service(&self, _cfg: Self::Config) -> Self::Future

Create and return a new service asynchronously.