plane-dynamic-proxy 0.5.5

Dynamic proxy crate for Plane
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

use axum::{body::Body, extract::Request, routing::any, Json, Router};
use http::Method;
use http_body_util::BodyExt;
use serde::{Deserialize, Serialize};
use std::{collections::HashMap, net::SocketAddr};
use tokio::net::TcpListener;

/// A simple server that returns the request info as json.
pub struct SimpleAxumServer {
    handle: tokio::task::JoinHandle<()>,
    addr: SocketAddr,
}

#[allow(unused)]
impl SimpleAxumServer {
    pub async fn new() -> Self {
        let app = Router::new()
            .route("/*path", any(return_request_info))
            .route("/", any(return_request_info));

        let addr = SocketAddr::from(([127, 0, 0, 1], 0));
        let tcp_listener = TcpListener::bind(addr).await.unwrap();
        let addr = tcp_listener.local_addr().unwrap();

        let handle = tokio::spawn(async {
            axum::serve(tcp_listener, app.into_make_service())
                .await
                .unwrap();
        });

        Self { handle, addr }
    }

    pub fn addr(&self) -> SocketAddr {
        self.addr
    }
}

impl Drop for SimpleAxumServer {
    fn drop(&mut self) {
        self.handle.abort();
    }
}

// Handler function for the root route
async fn return_request_info(method: Method, request: Request<Body>) -> Json<RequestInfo> {
    let method = method.to_string();

    let path = request.uri().path().to_string();
    let query = request.uri().query().unwrap_or("").to_string();

    let headers: HashMap<String, String> = request
        .headers()
        .iter()
        .map(|(k, v)| (k.to_string(), v.to_str().unwrap().to_string()))
        .collect();

    let body = request.into_body().collect().await.unwrap().to_bytes();
    let body = String::from_utf8(body.to_vec()).unwrap();

    Json(RequestInfo {
        path,
        query,
        method,
        headers,
        body,
    })
}

#[derive(Serialize, Deserialize)]
pub struct RequestInfo {
    pub path: String,
    pub query: String,
    pub method: String,
    pub headers: HashMap<String, String>,
    pub body: String,
}