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
|
use std::collections::HashMap;
use std::sync::Arc;
use http::code::Code;
use http::header::Header;
use http::request::Request;
use http::response::Response;
use tokio::net::{TcpListener, TcpStream};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use crate::bash::handle_script;
mod http;
mod bash;
async fn handle_response(mut socket: TcpStream, code: Code, body: String) {
let mut res = Response::new();
res.headers.put(Header::new("Content-Type", "text/plain"));
res.status = code;
res.body = Some(body);
let res_str = res.deserialize();
let _ = socket.write(res_str.as_bytes()).await;
}
async fn handle_connection(mut socket: TcpStream, config: Arc<HashMap<String, String>>) {
let mut buf = [0; 1204];
let n: usize = match socket.read(&mut buf).await {
Ok(n) if n == 0 => return,
Ok(n) => n as usize,
Err(e) => {
eprintln!("failed to read from socket; err = {:?}", e);
return
}
};
let str = String::from_utf8_lossy(&buf[0..n]);
let Some(req) = Request::serialize(&str) else {
return
};
let Some(script) = config.get(&req.uri.route) else {
handle_response(socket, Code::MethodNotAllowed, "Method Not Allowed".to_owned()).await;
return
};
match handle_script(script, req.body.as_ref()) {
Ok(out) => {
handle_response(socket, Code::Success, out).await;
},
Err(err) => {
handle_response(socket, Code::MethodNotAllowed, err).await;
},
}
}
#[tokio::main]
async fn main() {
let config = Arc::new(bash::load_config());
let port = std::env::var("PORT")
.unwrap_or_else(|_| String::from("8080"))
.parse::<u16>()
.unwrap_or_else(|_| 8080);
let addr = format!("127.0.0.1:{port}");
let Ok(listener) = TcpListener::bind(&addr).await else {
println!("failed to bind {addr}");
return
};
println!("listening to tcp requests on {addr}");
loop {
let Ok((socket, _)) = listener.accept().await else {
println!("failed to accept new connection");
continue
};
let config = config.clone();
tokio::spawn(async move {
handle_connection(socket, config).await;
});
}
}
|
