87 lines
2.7 KiB
Rust
87 lines
2.7 KiB
Rust
//! router aims to handle correctly the request corresponding to the target
|
|
//! it implements all the logic to build an `HTTPResponse`
|
|
|
|
use super::{HTTPRequest, HTTPResponse, HTTPStatusCode};
|
|
use crate::stores::FileStore;
|
|
use crate::stores::Store;
|
|
use lazy_static::lazy_static;
|
|
use std::collections::HashMap;
|
|
use std::future::Future;
|
|
use std::pin::Pin;
|
|
|
|
type FuturePinned<HTTPResponse> = Pin<Box<dyn Future<Output = HTTPResponse>>>;
|
|
type Handler = fn(HTTPRequest) -> FuturePinned<HTTPResponse>;
|
|
|
|
fn handle_get(request: HTTPRequest) -> FuturePinned<HTTPResponse> {
|
|
Box::pin(async move {
|
|
// TODO: path to `store.txt` must not be hardcoded, should be in a config file and load at runtime
|
|
let mut store = FileStore::new("tests/data/store.txt".to_string());
|
|
match &request.body {
|
|
Some(ref b) => {
|
|
let is_auth = store.is_auth(&b.get_data()).await;
|
|
if !is_auth {
|
|
return HTTPResponse::as_403();
|
|
}
|
|
HTTPResponse::as_200()
|
|
}
|
|
None => HTTPResponse::as_400(),
|
|
}
|
|
})
|
|
}
|
|
|
|
/// validates the token by checking:
|
|
/// * expiration time
|
|
fn handle_validate(request: HTTPRequest) -> FuturePinned<HTTPResponse> {
|
|
Box::pin(async move {
|
|
match &request.body {
|
|
Some(ref _b) => {
|
|
// TODO: impl the JWT validation
|
|
HTTPResponse::as_200()
|
|
}
|
|
None => HTTPResponse::as_400(),
|
|
}
|
|
})
|
|
}
|
|
|
|
lazy_static! {
|
|
/// defines the map between the URL and its associated callback
|
|
/// each authorized targets must implement a function returning `FuturePinned<HTTPResponse>`
|
|
// TODO: a macro should be implemented to mask the implementation details
|
|
static ref HTTP_METHODS: HashMap<&'static str, Handler> =
|
|
HashMap::from(
|
|
[
|
|
("/get/", handle_get as Handler),
|
|
("/validate/", handle_validate as Handler)
|
|
]
|
|
);
|
|
}
|
|
|
|
pub struct Router;
|
|
|
|
impl Router {
|
|
pub async fn route(&self, request_str: &str) -> HTTPResponse {
|
|
let request = HTTPRequest::from(request_str);
|
|
let target = request.start_line.get_target();
|
|
|
|
match HTTP_METHODS.get(target.as_str()) {
|
|
Some(f) => f(request).await,
|
|
None => HTTPResponse::as_404(),
|
|
}
|
|
}
|
|
}
|
|
|
|
// this MUST be used like a Singleton
|
|
pub const ROUTER: Router = Router {};
|
|
|
|
#[tokio::test]
|
|
async fn test_route() {
|
|
let router: &Router = &ROUTER;
|
|
let request_str = "POST /get/ HTTP/1.1\r\n\r\n";
|
|
|
|
let response: HTTPResponse = router.route(request_str).await;
|
|
assert_eq!(
|
|
HTTPStatusCode::Http400,
|
|
response.status_line.get_status_code()
|
|
);
|
|
}
|