Struct Proxy 

#[non_exhaustive]
pub struct Proxy<U, C>
where
    U: Upstreams,
    C: Client,
{
    pub upstreams: U,
    pub client: C,
    pub url_path_getter: UrlPartGetter,
    pub url_query_getter: UrlPartGetter,
    pub host_header_getter: HostHeaderGetter,
    pub client_ip_forwarding_enabled: bool,
    pub strict_path_normalization_enabled: bool,
    pub strip_authorization_header_enabled: bool,
}

Handler that can proxy request to other server.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

upstreams: U

Upstreams list.

client: C

Client for proxy.

url_path_getter: UrlPartGetter

URL path getter.

url_query_getter: UrlPartGetter

URL query getter.

host_header_getter: HostHeaderGetter

Host header getter

client_ip_forwarding_enabled: bool

Flag to enable x-forwarded-for header.

strict_path_normalization_enabled: bool

Flag to reject ambiguous percent-encoded path characters before proxying.

strip_authorization_header_enabled: bool

Flag to drop the inbound Authorization header before forwarding.

Implementations

impl<U> Proxy<U, HyperClient<HttpsConnector<HttpConnector>>>

where U: Upstreams, U::Error: Into<BoxedError>,

pub fn use_hyper_client(upstreams: U) -> Self

Available on crate feature hyper-client only.

Create a new Proxy using the default Hyper client.

This is a convenient way to create a proxy with standard configuration.

impl<U> Proxy<U, ReqwestClient>

where U: Upstreams, U::Error: Into<BoxedError>,

pub fn use_reqwest_client(upstreams: U) -> Self

Available on crate feature reqwest-client only.

Create a new Proxy using the default Reqwest client.

This is a convenient way to create a proxy with standard configuration.

impl<U> Proxy<U, UnixSockClient>

where U: Upstreams, U::Error: Into<BoxedError>,

pub fn use_unix_sock_tunnel(upstreams: U) -> Self

Available on crate feature unix-sock-client only.

Create a new Proxy that tunnels connections to a Unix socket.

impl<U, C> Proxy<U, C>

where U: Upstreams, U::Error: Into<BoxedError>, C: Client,

pub fn new(upstreams: U, client: C) -> Self

Creates a new Proxy with an upstream list.

The default host header getter is standard_host_header_getter, which forwards the upstream host and includes a non-default port (RFC 7230 / RFC 9110). To forward only the bare host name, configure default_host_header_getter via Self::host_header_getter.

pub fn with_client_ip_forwarding(upstreams: U, client: C) -> Self

Creates a new Proxy with an upstream list and enables the x-forwarded-for header.

Client IP forwarding overwrites any inbound X-Forwarded-For value with the direct client IP from the connection.

pub fn url_path_getter<G>(self, url_path_getter: G) -> Self

where G: Fn(&Request, &Depot) -> Option<String> + Send + Sync + 'static,

Set URL path getter.

pub fn url_query_getter<G>(self, url_query_getter: G) -> Self

where G: Fn(&Request, &Depot) -> Option<String> + Send + Sync + 'static,

Set URL query getter.

pub fn host_header_getter<G>(self, host_header_getter: G) -> Self

where G: Fn(&Uri, &Request, &Depot) -> Option<String> + Send + Sync + 'static,

Set host header getter.

pub fn strict_path_normalization(self, enable: bool) -> Self

Enable or disable strict path normalization.

When enabled, the proxy rejects literal parent-directory (..) path components and paths that still contain percent-encoded ., /, \, or % characters after Salvo routing has extracted the path tail. This is useful when the proxy is used as a security boundary and the upstream server may perform another decode or normalization pass.

pub fn upstreams(&self) -> &U

Get upstreams list.

pub fn upstreams_mut(&mut self) -> &mut U

Get upstreams mutable list.

pub fn client(&self) -> &C

Get client reference.

pub fn client_mut(&mut self) -> &mut C

Get client mutable reference.

pub fn client_ip_forwarding(self, enable: bool) -> Self

Enable x-forwarded-for header forwarding.

When enabled, the proxy overwrites any inbound X-Forwarded-For value with the direct client IP from the connection instead of trusting a client-supplied forwarding chain.

pub fn strip_authorization_header(self, enable: bool) -> Self

Drop the inbound Authorization header before forwarding the request upstream.

Disabled by default to preserve the typical reverse-proxy pass-through behaviour. Enable this when the proxy sits in front of services that should not see the caller’s credentials — for example a public CORS gateway, a third-party API bridge, or any deployment where the upstream is in a different trust domain than the inbound client.

Trait Implementations

impl<U, C> Debug for Proxy<U, C>

where U: Upstreams, C: Client,

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

Formats the value using the given formatter.

impl<U, C> Handler for Proxy<U, C>

where U: Upstreams, U::Error: Into<BoxedError>, C: Client,

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, _ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Handles one HTTP request.

fn arc(self) -> ArcHandler

where Self: Sized,

Wrap to ArcHandler.

fn hooped(self) -> HoopedHandler

where Self: Sized,

Wraps this handler in a HoopedHandler.

fn hoop<H>(self, hoop: H) -> HoopedHandler

where H: Handler, Self: Sized,

Hoop this handler with middleware.

fn hoop_when<H, F>(self, hoop: H, filter: F) -> HoopedHandler

where Self: Sized, H: Handler, F: Fn(&Request, &Depot) -> bool + Send + Sync + 'static,

Hoop this handler with middleware.