diff --git a/Cargo.lock b/Cargo.lock index c09eab7..8ee4025 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -635,8 +635,8 @@ dependencies = [ [[package]] name = "http" -version = "0.1.1" -source = "git+https://gitea.thegux.fr/rmanach/http#57dcb801e8919fd9acd19efa92c521d7551bc5b7" +version = "0.1.2" +source = "git+https://gitea.thegux.fr/rmanach/http#fb164ba137c3f1492f7452ac29d5d08afd30e87d" dependencies = [ "json", "lazy_static", diff --git a/Cargo.toml b/Cargo.toml index e9b5e72..f43bf0d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,7 +16,7 @@ simple_logger = "4.0.0" log = "0.4.17" base64 = "0.13.1" -http = { git = "https://gitea.thegux.fr/rmanach/http", version = "0.1.1" } +http = { git = "https://gitea.thegux.fr/rmanach/http", version = "0.1.2" } # useful for tests (embedded files should be delete in release ?) #rust-embed="6.4.1" diff --git a/src/http/message.rs b/src/http/message.rs deleted file mode 100644 index cbf4287..0000000 --- a/src/http/message.rs +++ /dev/null @@ -1,93 +0,0 @@ -use json; -use std::collections::HashMap; - -const JSON_DELIMITER: &'static str = ","; - -/// `HashMap` wrapper, represents the JSON response body -pub struct HTTPMessage { - message: HashMap, -} - -impl Default for HTTPMessage { - fn default() -> Self { - HTTPMessage { - message: HashMap::new(), - } - } -} - -/// try to convert `HTTPMessage` in `json::JsonValue` -impl TryInto for HTTPMessage { - type Error = String; - fn try_into(self) -> Result { - let message = format!(r#"{{{}}}"#, self.build_json()); - match json::parse(&message) { - Ok(r) => Ok(r), - Err(e) => Err(format!( - "unable to parse the HTTPMessage correctly: {}, err={}", - message, e - )), - } - } -} - -impl HTTPMessage { - pub fn put(&mut self, key: &str, value: &str) { - self.message.insert(key.to_string(), value.to_string()); - } - - /// associated function to build an HTTPMessage error - pub fn error(message: &str) -> Option { - let mut http_message = HTTPMessage::default(); - http_message.put("error", message); - - match message.try_into() { - Ok(m) => Some(m), - Err(e) => { - eprintln!( - "unable to parse the message: {} into JSON, err={}", - message, e - ); - return None; - } - } - } - - /// loops over all the HashMap keys, builds a JSON key value for each one and join them with `JSON_DELIMITER` - fn build_json(self) -> String { - let unstruct: Vec = self - .message - .keys() - .map(|k| format!(r#""{}":{:?}"#, k, self.message.get(k).unwrap())) - .collect(); - let joined = unstruct.join(JSON_DELIMITER); - joined - } -} - -#[test] -fn test_message() { - let mut http_message = HTTPMessage::default(); - http_message.put("email", "toto@toto.fr"); - http_message.put("password", "tata"); - - let mut json_result: Result = http_message.try_into(); - assert!(json_result.is_ok()); - - let mut json = json_result.unwrap(); - assert!(json.has_key("email")); - assert!(json.has_key("password")); - - let empty_http_message = HTTPMessage::default(); - json_result = empty_http_message.try_into(); - assert!(json_result.is_ok()); - - json = json_result.unwrap(); - assert_eq!("{}", json.dump().to_string()); - - let mut bad_http_message = HTTPMessage::default(); - bad_http_message.put("\"", ""); - - json_result = bad_http_message.try_into(); - assert!(json_result.is_err()); -} diff --git a/src/http/mod.rs b/src/http/mod.rs deleted file mode 100644 index db7e5a6..0000000 --- a/src/http/mod.rs +++ /dev/null @@ -1,9 +0,0 @@ -//! http module includes tools to parse an HTTP request and build and HTTP response - -pub mod message; -pub mod response; -pub mod router; - -pub use message::HTTPMessage; -pub use response::{HTTPResponse, HTTPStatusCode}; -pub use router::ROUTER; diff --git a/src/http/response.rs b/src/http/response.rs deleted file mode 100644 index 2ae4792..0000000 --- a/src/http/response.rs +++ /dev/null @@ -1,173 +0,0 @@ -//! response handles the incoming request parsed `HTTPRequest` -//! it will build an HTTPResponse corresponding to the HTTP message specs. see: https://developer.mozilla.org/en-US/docs/Web/HTTP/Messages -//! NOTE: only few parts of the specification has been implemented - -use super::HTTPMessage; -use http::HTTPVersion; -use json; - -#[derive(Debug, PartialEq, Clone)] -pub enum HTTPStatusCode { - Http200, - Http400, - Http403, - Http404, - Http500, -} - -impl Into for HTTPStatusCode { - fn into(self) -> String { - match self { - Self::Http200 => "200".to_string(), - Self::Http400 => "400".to_string(), - Self::Http404 => "404".to_string(), - Self::Http403 => "403".to_string(), - Self::Http500 => "500".to_string(), - } - } -} - -pub struct HTTPStatusLine { - version: HTTPVersion, - status_code: HTTPStatusCode, -} - -impl Default for HTTPStatusLine { - fn default() -> HTTPStatusLine { - HTTPStatusLine { - version: HTTPVersion::Http1_1, - status_code: HTTPStatusCode::Http400, - } - } -} - -impl Into for HTTPStatusLine { - fn into(self) -> String { - let version: String = self.version.into(); - let status_code: String = self.status_code.into(); - format! {"{} {}", version, status_code} - } -} - -impl HTTPStatusLine { - pub fn set_status_code(&mut self, code: HTTPStatusCode) { - self.status_code = code; - } - - #[allow(dead_code)] - pub fn get_status_code(&self) -> HTTPStatusCode { - self.status_code.clone() - } -} - -/// represents an HTTP response (headers are not parsed) -/// NOTE: for simplicity, only JSON body are accepted -pub struct HTTPResponse { - pub status_line: HTTPStatusLine, - body: json::JsonValue, -} - -impl Default for HTTPResponse { - fn default() -> Self { - HTTPResponse { - status_line: HTTPStatusLine::default(), - body: json::parse(r#"{"error": "the incoming request is not valid"}"#).unwrap(), - } - } -} - -impl Into for HTTPResponse { - fn into(self) -> String { - // move `self.body` into a new var - let b = self.body; - let body: String = json::stringify(b); - - let status_line: String = self.status_line.into(); - format!( - "{}\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}", - status_line, - body.len(), - body - ) - } -} - -impl HTTPResponse { - pub fn as_500(message: Option) -> Self { - let mut response = Self::default(); - - response - .status_line - .set_status_code(HTTPStatusCode::Http500); - - response.body = { - match message { - Some(m) => m, - None => json::parse(r#"{"error": "unexpected error occurred"}"#).unwrap(), - } - }; - - response - } - - pub fn as_404() -> Self { - let mut response = Self::default(); - - response - .status_line - .set_status_code(HTTPStatusCode::Http404); - response.body = json::parse(r#"{"error": "the url requested does not exist"}"#).unwrap(); - - response - } - - pub fn as_403() -> Self { - let mut response = HTTPResponse { - status_line: HTTPStatusLine::default(), - body: json::parse(r#"{"error": "invalid credentials"}"#).unwrap(), - }; - - response - .status_line - .set_status_code(HTTPStatusCode::Http403); - - response - } - - /// wrap the `Self::default()` associated func (not really clear) - pub fn as_400() -> Self { - Self::default() - } - - pub fn as_200(message: Option) -> Self { - let mut response = Self::default(); - - response - .status_line - .set_status_code(HTTPStatusCode::Http200); - - response.body = { - match message { - Some(m) => m, - None => json::parse(r#"{"status": "ok"}"#).unwrap(), - } - }; - - response - } - - /// builds an HTTP 200 response with the generated JWT - pub fn send_token(token: &str) -> Self { - let mut http_message = HTTPMessage::default(); - http_message.put("token", token); - - let message = { - match http_message.try_into() { - Ok(m) => m, - Err(_e) => json::parse(r#"{"token": "error.generation.token"}"#).unwrap(), - } - }; - - HTTPResponse::as_200(Some(message)) - } -} diff --git a/src/main.rs b/src/main.rs index fc92ad0..7407b1a 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,6 +1,6 @@ mod config; -mod http; mod jwt; +mod router; mod stores; mod utils; @@ -12,7 +12,7 @@ use tokio::{ time::{timeout, Duration}, }; -use crate::http::ROUTER; +use crate::router::ROUTER; use config::Config; #[derive(Parser)] diff --git a/src/router/mod.rs b/src/router/mod.rs new file mode 100644 index 0000000..16b5ebb --- /dev/null +++ b/src/router/mod.rs @@ -0,0 +1,4 @@ +//! router module includes all the handlers to get and validate JWT + +mod router; +pub use router::ROUTER; diff --git a/src/http/router.rs b/src/router/router.rs similarity index 77% rename from src/http/router.rs rename to src/router/router.rs index 6361497..3000e13 100644 --- a/src/http/router.rs +++ b/src/router/router.rs @@ -2,10 +2,9 @@ //! it implements all the logic to build an `HTTPResponse` use base64; -use http; -use json; +use http::{HTTPRequest, HTTPResponse, JSONMessage}; +use json::JsonValue; -use super::{HTTPMessage, HTTPResponse}; use crate::config::Config; use crate::jwt::JWTSigner; use crate::stores::{FileStore, Store}; @@ -15,7 +14,7 @@ const GET_ROUTE: &'static str = "/get/"; const VALIDATE_ROUTE: &'static str = "/validate/"; const PUBKEY_ROUTE: &'static str = "/pubkey/"; -async fn handle_get(request: http::HTTPRequest<'_>, config: Config, method: &str) -> HTTPResponse { +async fn handle_get(request: HTTPRequest<'_>, config: Config, method: &str) -> HTTPResponse { if method.trim().to_lowercase() != "post" { return HTTPResponse::as_400(); } @@ -33,16 +32,16 @@ async fn handle_get(request: http::HTTPRequest<'_>, config: Config, method: &str match JWTSigner::new(config).await { Ok(s) => s, Err(e) => { - let message = HTTPMessage::error(&e); + let message = JSONMessage::error(&e); return HTTPResponse::as_500(message); } } }; match jwt_signer.sign(credentials.unwrap().email) { - Ok(t) => HTTPResponse::send_token(&t), + Ok(t) => send_token(&t), Err(e) => { - let message = HTTPMessage::error(&e); + let message = JSONMessage::error(&e); return HTTPResponse::as_500(message); } } @@ -55,7 +54,7 @@ async fn handle_get(request: http::HTTPRequest<'_>, config: Config, method: &str /// * expiration time /// * signature async fn handle_validate( - request: http::HTTPRequest<'_>, + request: HTTPRequest<'_>, config: Config, method: &str, ) -> HTTPResponse { @@ -67,7 +66,7 @@ async fn handle_validate( match request.get_body_value("token") { Some(t) => t, None => { - let mut message = HTTPMessage::default(); + let mut message = JSONMessage::default(); message.put("valid", "false"); message.put("reason", "no token provided in the request body"); let json = message.try_into().unwrap(); @@ -81,14 +80,14 @@ async fn handle_validate( match JWTSigner::new(config).await { Ok(s) => s, Err(e) => { - let message = HTTPMessage::error(&e); + let message = JSONMessage::error(&e); let json = message.try_into().unwrap(); return HTTPResponse::as_500(Some(json)); } } }; - let mut message = HTTPMessage::default(); + let mut message = JSONMessage::default(); match jwt_signer.validate(&token) { Ok(()) => { message.put("valid", "true"); @@ -99,13 +98,13 @@ async fn handle_validate( } } - let json: json::JsonValue = message.try_into().unwrap(); + let json: JsonValue = message.try_into().unwrap(); HTTPResponse::as_200(Some(json)) } /// returns the JWT public key in base64 encoded async fn handle_public_key( - request: http::HTTPRequest<'_>, + request: HTTPRequest<'_>, config: Config, method: &str, ) -> HTTPResponse { @@ -117,7 +116,7 @@ async fn handle_public_key( match JWTSigner::new(config).await { Ok(s) => s, Err(e) => { - let message = HTTPMessage::error(&e); + let message = JSONMessage::error(&e); let json = message.try_into().unwrap(); return HTTPResponse::as_500(Some(json)); } @@ -126,7 +125,7 @@ async fn handle_public_key( let public_key = jwt_signer.get_public_key(); - let mut message = HTTPMessage::default(); + let mut message = JSONMessage::default(); message.put("pubkey", &base64::encode(public_key)); let json = message.try_into().unwrap(); @@ -138,7 +137,7 @@ pub struct Router; impl Router { /// routes the request to the corresponding handling method pub async fn route(&self, request_str: &str, config: Config) -> HTTPResponse { - let request = http::HTTPRequest::from(request_str); + let request = HTTPRequest::from(request_str); match request.get_target() { GET_ROUTE => handle_get(request, config, "post").await, VALIDATE_ROUTE => handle_validate(request, config, "post").await, @@ -148,12 +147,27 @@ impl Router { } } +/// send_token generates an HTTPResponse with the new token +pub fn send_token(token: &str) -> HTTPResponse { + let mut message = JSONMessage::default(); + message.put("token", token); + + let json = { + match message.try_into() { + Ok(m) => m, + Err(_e) => json::parse(r#"{"token": "error.generation.token"}"#).unwrap(), + } + }; + + HTTPResponse::as_200(Some(json)) +} + // this MUST be used like a Singleton pub const ROUTER: Router = Router {}; #[tokio::test] async fn test_route() { - use super::HTTPStatusCode; + use http::HTTPStatusCode; let router: &Router = &ROUTER; let config: Config = Config::default(); diff --git a/tests/bash/curling.bash b/tests/bash/curling.bash index 5bd0be3..fe863c4 100755 --- a/tests/bash/curling.bash +++ b/tests/bash/curling.bash @@ -22,7 +22,7 @@ do exit 1 fi - if [ "$(cat response.txt | jq -r '.error')" != "invalid credentials" ] + if [ "$(cat response.txt | jq -r '.error')" != "url forbidden" ] then echo "bad data returned, expect : invalid credentials" exit 1 diff --git a/tests/python/test_requests.py b/tests/python/test_requests.py index 16be103..8701f04 100644 --- a/tests/python/test_requests.py +++ b/tests/python/test_requests.py @@ -78,7 +78,7 @@ class TestResponse(TestCase): self.assertIsNotNone(resp.json(), "response data can't be empty") self.assertEqual( resp.json()["error"], - "the url requested does not exist", + "url not found", "bad status returned", ) @@ -88,7 +88,7 @@ class TestResponse(TestCase): self.assertIsNotNone(resp.json(), "response data must not be empty") self.assertEqual( resp.json()["error"], - "the incoming request is not valid", + "bad request", "invalid error message returned", ) @@ -98,7 +98,7 @@ class TestResponse(TestCase): self.assertIsNotNone(resp.json(), "response data must not be empty") self.assertEqual( resp.json()["error"], - "invalid credentials", + "url forbidden", "invalid error message returned", ) @@ -110,7 +110,7 @@ class TestResponse(TestCase): self.assertIsNotNone(resp.json(), "response data must not be empty") self.assertEqual( resp.json()["error"], - "the url requested does not exist", + "url not found", "invalid error message returned", ) @@ -133,6 +133,6 @@ class TestResponse(TestCase): self.assertIsNotNone(resp.json(), "response data must not be empty") self.assertEqual( resp.json()["error"], - "the incoming request is not valid", + "bad request", "invalid error message returned", )