aex 0.1.6

A web server for rust.
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use aex::connection::context::TypeMapExt;
use aex::exe;
use aex::http::meta::HttpMetadata;
use aex::http::protocol::header::HeaderKey;
use aex::http::router::{NodeType, Router as HttpRouter};
use aex::http::types::Executor;
use aex::server::HTTPServer;
use aex::tcp::types::{Command, RawCodec};
use std::net::SocketAddr;
use std::sync::Arc;

fn auth_middleware() -> Arc<Executor> {
    exe!(|ctx| {
        let meta = ctx.local.get_value::<HttpMetadata>().unwrap();
        let auth_header = meta.headers.get(&HeaderKey::Authorization);

        if auth_header.is_none() {
            ctx.send("Unauthorized: Missing Authorization header", None);
            return false;
        }

        let token = auth_header.unwrap();
        if !token.starts_with("Bearer ") {
            ctx.send("Unauthorized: Invalid token format", None);
            return false;
        }

        ctx.local.set_value::<String>("user_123".to_string());
        true
    })
}

fn logging_middleware() -> Arc<Executor> {
    exe!(|ctx| {
        let meta = ctx.local.get_value::<HttpMetadata>().unwrap();
        println!("[{:?}] {} {}", meta.method, meta.path, ctx.addr);
        true
    })
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let addr: SocketAddr = "0.0.0.0:8080".parse()?;
    let mut router = HttpRouter::new(NodeType::Static("root".into()));

    let auth = auth_middleware();
    let logger = logging_middleware();

    router
        .get(
            "/api/users",
            exe!(|ctx| {
                ctx.send(r#"["user1", "user2", "user3"]"#, None);
                true
            }),
        )
        .middleware(logger.clone())
        .register();

    router
        .get(
            "/api/users/:id",
            exe!(|ctx| {
                let meta = ctx.local.get_value::<HttpMetadata>().unwrap();
                let id = meta
                    .params
                    .as_ref()
                    .and_then(|p| p.data.as_ref())
                    .and_then(|d| d.get("id"))
                    .map(|v| v.as_str())
                    .unwrap_or("unknown");
                ctx.send(format!(r#"{{"id":"{}","name":"User {}"}}"#, id, id), None);
                true
            }),
        )
        .middleware(auth.clone())
        .middleware(logger.clone())
        .register();

    router
        .post(
            "/api/users",
            exe!(|ctx| {
                let meta = ctx.local.get_value::<HttpMetadata>().unwrap();
                let body = String::from_utf8_lossy(&meta.body);
                println!("Create user: {}", body);
                ctx.send(format!(r#"{{"status":"created","data":{}}}"#, body), None);
                true
            }),
        )
        .middleware(auth.clone())
        .middleware(logger.clone())
        .register();

    router
        .get(
            "/public/*",
            exe!(|ctx| {
                let meta = ctx.local.get_value::<HttpMetadata>().unwrap();
                ctx.send(format!(r#"{{"path":"{}"}}"#, meta.path), None);
                true
            }),
        )
        .register();

    println!("Server running at http://{}", addr);
    println!("Try:");
    println!("  curl http://{}/public/info", addr);
    println!("  curl http://{}/api/users", addr);
    println!(
        "  curl -H 'Authorization: Bearer token' http://{}/api/users/123",
        addr
    );

    HTTPServer::new(addr, None).http(router).start().await?;
    Ok(())
}