kitsune2_bootstrap_srv 0.2.13

p2p / dht communication WAN discovery bootstrapping server
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

use base64::prelude::*;
use rand::Rng;

#[tokio::main]
async fn main() {
    const USAGE: &str = "usage: test-auth-hook-server <0.0.0.0:0>";
    let mut arg_iter = std::env::args();
    arg_iter.next().expect(USAGE);
    let bind: std::net::SocketAddr =
        arg_iter.next().expect(USAGE).parse().expect(USAGE);

    println!("#STARTUP_AT#{bind}#");

    async fn handle_auth(body: bytes::Bytes) -> axum::response::Response {
        if &body[..] != b"valid" {
            return axum::response::IntoResponse::into_response((
                axum::http::StatusCode::UNAUTHORIZED,
                "Unauthorized",
            ));
        }
        let mut token = [0; 32];
        rand::thread_rng().fill(&mut token);
        let token = BASE64_URL_SAFE_NO_PAD.encode(&token[..]);
        axum::response::IntoResponse::into_response(axum::Json(
            serde_json::json!({
                "authToken": token,
            }),
        ))
    }

    let app: axum::Router<()> = axum::Router::new()
        .route("/authenticate", axum::routing::put(handle_auth));

    let h = axum_server::Handle::default();
    let h2 = h.clone();

    let task = tokio::task::spawn(async move {
        axum_server::bind(bind)
            .handle(h2)
            .serve(app.into_make_service_with_connect_info::<std::net::SocketAddr>())
            .await
            .unwrap();
    });

    let hook_addr = h.listening().await.unwrap();

    println!("#SERVER_RUNNING#http://{hook_addr:?}/authenticate#");

    task.await.unwrap();
}