123 lines
4.2 KiB
Rust
123 lines
4.2 KiB
Rust
//! router aims to handle correctly the request corresponding to the target
|
|
//! it implements all the logic to build an `HTTPResponse`
|
|
|
|
use super::{HTTPMessage, HTTPRequest, HTTPResponse};
|
|
use crate::config::Config;
|
|
use crate::stores::FileStore;
|
|
use crate::stores::Store;
|
|
use jwt_simple::prelude::*;
|
|
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, Config) -> FuturePinned<HTTPResponse>;
|
|
|
|
fn handle_get(request: HTTPRequest, config: Config) -> FuturePinned<HTTPResponse> {
|
|
Box::pin(async move {
|
|
let mut store = FileStore::new(config.filestore_path);
|
|
match &request.body {
|
|
Some(ref b) => {
|
|
let is_auth = store.is_auth(&b.get_data()).await;
|
|
if !is_auth {
|
|
return HTTPResponse::as_403();
|
|
}
|
|
|
|
let priv_key_content = {
|
|
match std::fs::read_to_string(config.jwt_priv_key) {
|
|
Ok(c) => c,
|
|
Err(e) => {
|
|
eprintln!("error while reading JWT priv key content err={}", e);
|
|
"".to_string()
|
|
}
|
|
}
|
|
};
|
|
let jwt_key = {
|
|
match RS384KeyPair::from_pem(priv_key_content.as_str()) {
|
|
Ok(k) => k,
|
|
Err(e) => {
|
|
let message: Option<json::JsonValue> = HTTPMessage::error(
|
|
format!("unable to load the private key, err={}", e).as_str(),
|
|
);
|
|
return HTTPResponse::as_500(message);
|
|
}
|
|
}
|
|
};
|
|
let mut claims = Claims::create(Duration::from_hours(config.jwt_exp_time));
|
|
claims.issuer = Some(config.jwt_issuer);
|
|
|
|
match jwt_key.sign(claims) {
|
|
Ok(token) => HTTPResponse::send_token(&token),
|
|
Err(e) => {
|
|
let message: Option<json::JsonValue> = HTTPMessage::error(
|
|
format!("unable to sign the token, err={}", e).as_str(),
|
|
);
|
|
return HTTPResponse::as_500(message);
|
|
}
|
|
}
|
|
}
|
|
None => HTTPResponse::as_400(),
|
|
}
|
|
})
|
|
}
|
|
|
|
/// validates the token by checking:
|
|
/// * expiration time
|
|
fn handle_validate(request: HTTPRequest, _config: Config) -> FuturePinned<HTTPResponse> {
|
|
Box::pin(async move {
|
|
match &request.body {
|
|
Some(ref _b) => {
|
|
// TODO: impl the JWT validation
|
|
HTTPResponse::send_token("header.payload.signature")
|
|
}
|
|
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, config: Config) -> 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, config).await,
|
|
None => HTTPResponse::as_404(),
|
|
}
|
|
}
|
|
}
|
|
|
|
// this MUST be used like a Singleton
|
|
pub const ROUTER: Router = Router {};
|
|
|
|
#[tokio::test]
|
|
async fn test_route() {
|
|
use super::HTTPStatusCode;
|
|
|
|
let router: &Router = &ROUTER;
|
|
let config: Config = Config::default();
|
|
let request_str = "POST /get/ HTTP/1.1\r\n\r\n";
|
|
|
|
let response: HTTPResponse = router.route(request_str, config).await;
|
|
assert_eq!(
|
|
HTTPStatusCode::Http400,
|
|
response.status_line.get_status_code()
|
|
);
|
|
}
|