From 758774306eaa6032fc66c18ec5c358fa6c6133a4 Mon Sep 17 00:00:00 2001 From: Pierre HUBERT Date: Fri, 11 Mar 2022 21:33:14 +0100 Subject: [PATCH] Start to work on new route system --- src/routes.rs | 70 +++++++++++++++++++++++++++++++++++---------------- src/server.rs | 36 ++++++++------------------ 2 files changed, 59 insertions(+), 47 deletions(-) diff --git a/src/routes.rs b/src/routes.rs index 29c8449..0f0d1fe 100644 --- a/src/routes.rs +++ b/src/routes.rs @@ -1,7 +1,7 @@ use std::error::Error; use crate::constants::admin::AdminRole; -use crate::controllers::{account_controller, comments_controller, conversations_controller, forez_controller, friends_controller, groups_controller, likes_controller, notifications_controller, posts_controller, push_notifications_controller, search_controller, server_controller, settings_controller, surveys_controller, user_controller, user_ws_controller, virtual_directory_controller, web_app_controller}; +use crate::controllers::*; use crate::controllers::admin::*; use crate::data::http_request_handler::HttpRequestHandler; use crate::routes::Method::{GET, POST}; @@ -77,9 +77,6 @@ pub struct Route { /// If set to true, unauthenticated requests will be rejected pub need_login: bool, - /// The function called to process a request - pub func: RequestProcess, - /// Request rate policy pub limit_policy: LimitPolicy, @@ -88,105 +85,134 @@ pub struct Route { } impl Route { - pub fn get_without_login(uri: &'static str, func: RequestProcess) -> Route { + pub fn get_without_login(uri: &'static str) -> Route { Route { scope: RouteScope::USER, method: GET, need_login: false, uri, - func, limit_policy: LimitPolicy::NONE, admin_role: None, } } - pub fn post_without_login(uri: &'static str, func: RequestProcess) -> Route { + pub fn post_without_login(uri: &'static str) -> Route { Route { scope: RouteScope::USER, method: POST, need_login: false, uri, - func, limit_policy: LimitPolicy::NONE, admin_role: None, } } - pub fn limited_post_without_login(uri: &'static str, func: RequestProcess, limit_policy: LimitPolicy) -> Route { + pub fn limited_post_without_login(uri: &'static str, limit_policy: LimitPolicy) -> Route { Route { scope: RouteScope::USER, method: POST, need_login: false, uri, - func, limit_policy, admin_role: None, } } - pub fn post(uri: &'static str, func: RequestProcess) -> Route { + pub fn post(uri: &'static str) -> Route { Route { scope: RouteScope::USER, method: POST, need_login: true, uri, - func, limit_policy: LimitPolicy::NONE, admin_role: None, } } - pub fn limited_post(uri: &'static str, func: RequestProcess, limit_policy: LimitPolicy) -> Route { + pub fn limited_post(uri: &'static str, limit_policy: LimitPolicy) -> Route { Route { scope: RouteScope::USER, method: POST, need_login: true, uri, - func, limit_policy, admin_role: None, } } - pub fn limited_admin_post_without_login(uri: &'static str, func: RequestProcess, limit_policy: LimitPolicy) -> Route { + pub fn limited_admin_post_without_login(uri: &'static str, limit_policy: LimitPolicy) -> Route { Route { scope: RouteScope::ADMIN, method: POST, need_login: false, uri, - func, limit_policy, admin_role: None, } } - pub fn admin_post(uri: &'static str, func: RequestProcess) -> Route { + pub fn admin_post(uri: &'static str) -> Route { Route { scope: RouteScope::ADMIN, method: POST, need_login: true, uri, - func, limit_policy: LimitPolicy::NONE, admin_role: None, } } - pub fn admin_post_restricted(uri: &'static str, func: RequestProcess, role: AdminRole) -> Route { + pub fn admin_post_restricted(uri: &'static str, role: AdminRole) -> Route { Route { scope: RouteScope::ADMIN, method: POST, need_login: true, uri, - func, limit_policy: LimitPolicy::NONE, admin_role: Some(role), } } } + +macro_rules! route { + ($r : expr, $req_uri: expr, $call: expr, GET_NO_LOGIN, $uri: expr, $func: expr)=>{ + if($uri.eq($req_uri)) + { + $r = Some(Route::get_without_login($uri)); + + if let Some(c) = $call { + return ($r, Some($func(c))); + } + } + }; + + ($r : expr, $req_uri: expr, $call: expr, POST_NO_LOGIN, $uri: expr, $func: expr)=>{ + if($uri.eq($req_uri)) + { + $r = Some(Route::post_without_login($uri)); + + if let Some(c) = $call { + return ($r, Some($func(c))); + } + } + }; +} + +pub async fn find_route(req_uri: &str, call: Option<&mut HttpRequestHandler>) -> (Option, Option) { + let mut r = None; + + // Server meta routes + route!(r, req_uri, call, GET_NO_LOGIN, "/", server_controller::main_index); + route!(r, req_uri, call, POST_NO_LOGIN, "/server/config", server_controller::get_config); + + (r, None) +} + +/* /// Get the list of routes available -pub fn get_routes() -> Vec { +pub fn get_routes(route: &str) -> Vec { + vec![ // Server meta routes Route::get_without_login("/", Box::new(server_controller::main_index)), @@ -401,4 +427,4 @@ pub fn get_routes() -> Vec { Route::admin_post("/admin/users/change_email_address", Box::new(admin_users_controller::change_email_address)), Route::admin_post("/admin/users/create_password_reset_link", Box::new(admin_users_controller::create_password_reset_link)), ] -} \ No newline at end of file +}*/ \ No newline at end of file diff --git a/src/server.rs b/src/server.rs index 4ac8bd2..0b7085b 100644 --- a/src/server.rs +++ b/src/server.rs @@ -18,7 +18,7 @@ use crate::data::base_request_handler::{BaseRequestHandler, PostFile, RequestVal use crate::data::config::Config; use crate::data::http_request_handler::HttpRequestHandler; use crate::helpers::{admin_access_token_helper, admin_key_authentication_challenges_helper, admin_key_registration_challenges_helper, api_helper, requests_limit_helper}; -use crate::routes::{get_routes, RequestResult, Route, RouteScope}; +use crate::routes::{find_route, RequestResult, Route, RouteScope}; use crate::routes::Method::{GET, POST}; use crate::utils::user_data_utils::user_data_path; @@ -236,7 +236,8 @@ async fn process_simple_route(route: &Route, req: &mut HttpRequestHandler) -> Re } - let res: RequestResult = (route.func)(req); + let (_, res) = find_route(route.uri, Some(req)).await; + let res = res.unwrap(); requests_limit_helper::trigger_after(res.is_ok(), req, route)?; @@ -246,31 +247,16 @@ async fn process_simple_route(route: &Route, req: &mut HttpRequestHandler) -> Re /// Process an incoming request async fn process_request(custom_req: CustomRequest) -> HttpResponse { let req = &custom_req.req; - let routes = get_routes(); + let (route, _) = find_route(&req.uri().to_string(), None).await; - // We search the appropriate route for the request - let mut route: Option<&Route> = None; - for el in &routes { - - // Check verb - if !(req.method() == http::Method::GET && el.method == GET) && - !(req.method() == http::Method::POST && el.method == POST) { - continue; - } - - // Check path - if !el.uri.eq(req.uri()) { - continue; - } - - route = Some(el); - break; - } - - // Check if a route was found - if let None = route { + // Check if a route was found with the right verb + if !route.as_ref().map(|r| + (req.method() == http::Method::GET && r.method == GET) || + (req.method() == http::Method::POST && r.method == POST) + ).unwrap_or(false) { return HttpResponse::NotFound().json(HttpError::not_found("Route not found!")); } + let route = route.unwrap(); // Clean requests limit @@ -279,7 +265,7 @@ async fn process_request(custom_req: CustomRequest) -> HttpResponse { // Execute the request let mut request = HttpRequestHandler::new(custom_req.req, custom_req.body); - match process_simple_route(route, &mut request).await { + match process_simple_route(&route, &mut request).await { // Set default error response if required Err(e) => {