Struct rama::http::layer::forwarded::GetForwardedHeadersLayer

pub struct GetForwardedHeadersLayer<T = Forwarded> { /* private fields */ }

Layer to extract Forwarded information from the specified T headers.

This layer can be used to extract the Forwarded information from any specified header T, as long as the header implements the ForwardHeader trait. Multiple headers can be specified as a tuple, and the layer will extract information from them all, and combine the information.

Please take into consideration the following when combining headers:

• The last header in the tuple will take precedence over the previous headers, if the same information is present in multiple headers.
• Headers that can contain multiple elements, (e.g. X-Forwarded-For, Via) will combine their elements in the order as specified. That does however mean that in case one header has less elements then the other, that the combination down the line will not be accurate.

The following headers are supported by default:

• GetForwardedHeadersLayer::forwarded: The standard Forwarded header RFC 7239.
• GetForwardedHeadersLayer::via: The canonical Via header RFC 7230.
• GetForwardedHeadersLayer::x_forwarded_for: The canonical [X-Forwarded-For] header RFC 7239.
• GetForwardedHeadersLayer::x_forwarded_host: The canonical [X-Forwarded-Host] header RFC 7239.
• GetForwardedHeadersLayer::x_forwarded_proto: The canonical [X-Forwarded-Proto] header RFC 7239.

Rama also has the following headers already implemented for you to use:

X-Real-Ip, X-Client-Ip, Client-Ip, Cf-Connecting-Ip and True-Client-Ip.

There are no GetForwardedHeadersLayer constructors for these headers, but you can use the GetForwardedHeadersLayer::new constructor and pass the header type as a type parameter, alone or in a tuple with other headers.

Example

This example shows you can extract the client IP from the X-Forwarded-For header in case your application is behind a proxy which sets this header.

use rama_core::{
    service::service_fn,
    Context, Service, Layer,
};
use rama_http::{headers::Forwarded, layer::forwarded::GetForwardedHeadersLayer, Request};
use std::{convert::Infallible, net::IpAddr};

#[tokio::main]
async fn main() {
    let service = GetForwardedHeadersLayer::x_forwarded_for()
        .layer(service_fn(|ctx: Context<()>, _| async move {
            let forwarded = ctx.get::<Forwarded>().unwrap();
            assert_eq!(forwarded.client_ip(), Some(IpAddr::from([12, 23, 34, 45])));
            assert!(forwarded.client_proto().is_none());

            // ...

            Ok::<_, Infallible>(())
        }));

    let req = Request::builder()
        .header("X-Forwarded-For", "12.23.34.45")
        .body(())
        .unwrap();

    service.serve(Context::default(), req).await.unwrap();
}

Implementations

impl<T> GetForwardedHeadersLayer<T>

pub const fn new() -> GetForwardedHeadersLayer<T>

Create a new GetForwardedHeadersLayer for the specified headers T.

impl GetForwardedHeadersLayer

pub fn forwarded() -> GetForwardedHeadersLayer

Create a new GetForwardedHeadersLayer for the standard Forwarded header.

impl GetForwardedHeadersLayer<Via>

pub fn via() -> GetForwardedHeadersLayer<Via>

Create a new GetForwardedHeadersLayer for the canonical Via header.

impl GetForwardedHeadersLayer<XForwardedFor>

pub fn x_forwarded_for() -> GetForwardedHeadersLayer<XForwardedFor>

Create a new GetForwardedHeadersLayer for the canonical [X-Forwarded-For] header.

impl GetForwardedHeadersLayer<XForwardedHost>

pub fn x_forwarded_host() -> GetForwardedHeadersLayer<XForwardedHost>

Create a new GetForwardedHeadersLayer for the canonical [X-Forwarded-Host] header.

impl GetForwardedHeadersLayer<XForwardedProto>

pub fn x_forwarded_proto() -> GetForwardedHeadersLayer<XForwardedProto>

Create a new GetForwardedHeadersLayer for the canonical [X-Forwarded-Proto] header.

Trait Implementations

impl<T> Clone for GetForwardedHeadersLayer<T>

where T: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for GetForwardedHeadersLayer<T>

where T: Debug,

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

Formats the value using the given formatter.

impl Default for GetForwardedHeadersLayer

fn default() -> GetForwardedHeadersLayer

Returns the “default value” for a type.

impl<H, S> Layer<S> for GetForwardedHeadersLayer<H>

type Service = GetForwardedHeadersService<S, H>

The service produced by the layer.

fn layer(&self, inner: S) -> <GetForwardedHeadersLayer<H> as Layer<S>>::Service

Wrap the given service with the middleware, returning a new service.