Struct H2ReverseProxy 

pub struct H2ReverseProxy { /* private fields */ }

Reverse proxy that forwards requests to HTTP/2 backends.

Wraps ReverseProxy and forces HTTP/2 (h2) for all upstream connections. Requires the http2 Cargo feature.

This proxy also transparently handles gRPC traffic (Content-Type: application/grpc*) — gRPC DATA frames are forwarded as-is because gRPC is layered directly on HTTP/2.

Implementations

impl H2ReverseProxy

pub fn new<I, S>(backends: I) -> Self

where I: IntoIterator<Item = S>, S: AsRef<str>,

Create a proxy distributing requests across backends in round-robin order.

Each backend entry can be:

• "host:port" — plain TCP (HTTP/2 cleartext)
• "h2://host:port" — plain TCP (explicit scheme)
• "h2s://host:port" — TLS (HTTP/2 over HTTPS; port defaults to 443)
• "https://host:port" — TLS (same as h2s://)

TLS backends require the http2 Cargo feature (includes rustls + webpki-roots). Certificate verification uses the WebPKI trust store.

pub fn path_prefix(self, prefix: impl Into<String>) -> Self

Only proxy requests whose URI starts with prefix; pass others through.

pub fn connect_timeout_ms(self, ms: u64) -> Self

Override the TCP connect timeout (default: 5 s).

pub fn read_timeout_ms(self, ms: u64) -> Self

Override the read timeout (default: 30 s). It bounds each wait for the upstream — the handshake, the response head, every body frame — so a streaming response (a gRPC server stream) ends only when it goes quiet for that long.

pub fn tls_ca_file(self, path: &str) -> Result<Self, String>

Trust the CA certificates in the PEM file path for h2s:// / https:// backends instead of the WebPKI roots. Since 18.3.0.

pub fn tls_client_cert(self, cert: &str, key: &str) -> Result<Self, String>

Present a client certificate to TLS backends that require one (mutual TLS). Since 18.3.0.

Trait Implementations

impl Middleware for H2ReverseProxy

Available on crate feature http2 only.

fn accepts_streamed_body( &self, _request: &Request, _connection: &ConnectionInfo, ) -> bool

Headers only: a request this proxy doesn’t forward passes through untouched.

fn answers_streamed_body( &self, request: &Request, _connection: &ConnectionInfo, ) -> bool

Requests this proxy forwards are sent as their body arrives (gRPC client streaming and bidirectional calls).

fn handle( &self, request: &Request, connection: &ConnectionInfo, next: &dyn Application, ) -> Result<Response, String>

fn runs_inline(&self, _request: &Request, _connection: &ConnectionInfo) -> bool

true when this layer’s own work for request never blocks (in-memory state, atomics, short mutexes) — see Application::runs_inline. A WithMiddleware stack runs inline only if every layer and the inner application agree. Default false.

fn is_passthrough( &self, _request: &Request, _connection: &ConnectionInfo, ) -> bool

true when handle would do nothing for request but call next (e.g. a rate limit that isn’t configured). A WithMiddleware stack offers the inner application’s execute_async only if every layer passes the request through. Default false.