plane 0.5.5

Session backend orchestrator for ambitious browser-based apps.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use axum::{
    body::{Body, Bytes},
    extract::{Request, State},
    http::Uri,
    http::{request, HeaderValue, StatusCode},
    middleware::Next,
    response::Response,
};
use hyper_util::{
    client::legacy::{connect::HttpConnector, Client},
    rt::TokioExecutor,
};
use url::Url;

pub fn clone_request_with_empty_body(parts: &request::Parts) -> hyper::http::Request<Body> {
    // Copy method and URL.
    let mut builder = hyper::http::request::Builder::new()
        .method(parts.method.clone())
        .uri(parts.uri.clone());

    // Copy headers.
    let headers = builder
        .headers_mut()
        .expect("Can always call headers_mut() on a new builder.");

    headers.extend(parts.headers.clone());

    headers.insert(
        "x-original-path",
        HeaderValue::from_str(parts.uri.path()).expect("Path is always valid."),
    );

    // Construct with an empty body.
    builder
        .body(Body::empty())
        .expect("Request is always valid.")
}

pub async fn forward_layer(State(forward_url): State<Url>, req: Request, next: Next) -> Response {
    let (parts, body) = req.into_parts();
    let mut forward_req = clone_request_with_empty_body(&parts);
    let req = Request::from_parts(parts, body);

    let uri = forward_url
        .to_string()
        .parse::<Uri>()
        .expect("Url should always parse as hyper Uri.");
    *forward_req.uri_mut() = uri;

    // Create a client
    let client = Client::builder(TokioExecutor::new()).build(HttpConnector::new());

    // Forward the request
    let forwarded_resp = client.request(forward_req).await;

    let forwarded_resp = match forwarded_resp {
        Ok(resp) => resp,
        Err(err) => {
            tracing::error!(?err, "Error forwarding auth.");
            return response_helper(StatusCode::BAD_GATEWAY, b"Error forwarding auth.");
        }
    };

    if forwarded_resp.status().is_success() {
        next.run(req).await
    } else {
        response_helper(StatusCode::UNAUTHORIZED, b"Unauthorized")
    }
}

fn response_helper(status: StatusCode, body: &'static [u8]) -> Response {
    let body = Body::from(Bytes::from_static(body));

    Response::builder()
        .status(status.as_u16())
        .body(body)
        .expect("Response is always valid.")
}