Add better error handling for bad requests
This commit is contained in:
onyinyang
parent
e1f7cda652
commit
9c959486be
|
|
@ -10,6 +10,7 @@ use lox::{
|
|||
};
|
||||
use lox_utils;
|
||||
use std::sync::{Arc, Mutex};
|
||||
use zkp::ProofError;
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct LoxServerContext {
|
||||
|
|
@ -119,127 +120,239 @@ impl LoxServerContext {
|
|||
}
|
||||
}
|
||||
|
||||
fn open_inv(&self, req: open_invite::Request) -> open_invite::Response {
|
||||
fn open_inv(&self, req: open_invite::Request) -> Result<open_invite::Response, ProofError> {
|
||||
let mut ba_obj = self.ba.lock().unwrap();
|
||||
ba_obj.handle_open_invite(req).unwrap()
|
||||
ba_obj.handle_open_invite(req)
|
||||
}
|
||||
|
||||
fn trust_promo(&self, req: trust_promotion::Request) -> trust_promotion::Response {
|
||||
fn trust_promo(
|
||||
&self,
|
||||
req: trust_promotion::Request,
|
||||
) -> Result<trust_promotion::Response, ProofError> {
|
||||
let mut ba_obj = self.ba.lock().unwrap();
|
||||
ba_obj.handle_trust_promotion(req).unwrap()
|
||||
ba_obj.handle_trust_promotion(req)
|
||||
}
|
||||
|
||||
fn trust_migration(&self, req: migration::Request) -> migration::Response {
|
||||
fn trust_migration(&self, req: migration::Request) -> Result<migration::Response, ProofError> {
|
||||
let mut ba_obj = self.ba.lock().unwrap();
|
||||
ba_obj.handle_migration(req).unwrap()
|
||||
ba_obj.handle_migration(req)
|
||||
}
|
||||
|
||||
fn level_up(&self, req: level_up::Request) -> level_up::Response {
|
||||
fn level_up(&self, req: level_up::Request) -> Result<level_up::Response, ProofError> {
|
||||
let mut ba_obj = self.ba.lock().unwrap();
|
||||
ba_obj.handle_level_up(req).unwrap()
|
||||
ba_obj.handle_level_up(req)
|
||||
}
|
||||
|
||||
fn issue_invite(&self, req: issue_invite::Request) -> issue_invite::Response {
|
||||
fn issue_invite(
|
||||
&self,
|
||||
req: issue_invite::Request,
|
||||
) -> Result<issue_invite::Response, ProofError> {
|
||||
let mut ba_obj = self.ba.lock().unwrap();
|
||||
ba_obj.handle_issue_invite(req).unwrap()
|
||||
ba_obj.handle_issue_invite(req)
|
||||
}
|
||||
|
||||
fn redeem_invite(&self, req: redeem_invite::Request) -> redeem_invite::Response {
|
||||
fn redeem_invite(
|
||||
&self,
|
||||
req: redeem_invite::Request,
|
||||
) -> Result<redeem_invite::Response, ProofError> {
|
||||
let mut ba_obj = self.ba.lock().unwrap();
|
||||
ba_obj.handle_redeem_invite(req).unwrap()
|
||||
ba_obj.handle_redeem_invite(req)
|
||||
}
|
||||
|
||||
fn check_blockage(&self, req: check_blockage::Request) -> check_blockage::Response {
|
||||
fn check_blockage(
|
||||
&self,
|
||||
req: check_blockage::Request,
|
||||
) -> Result<check_blockage::Response, ProofError> {
|
||||
let mut ba_obj = self.ba.lock().unwrap();
|
||||
ba_obj.handle_check_blockage(req).unwrap()
|
||||
ba_obj.handle_check_blockage(req)
|
||||
}
|
||||
|
||||
fn blockage_migration(&self, req: blockage_migration::Request) -> blockage_migration::Response {
|
||||
fn blockage_migration(
|
||||
&self,
|
||||
req: blockage_migration::Request,
|
||||
) -> Result<blockage_migration::Response, ProofError> {
|
||||
let mut ba_obj = self.ba.lock().unwrap();
|
||||
ba_obj.handle_blockage_migration(req).unwrap()
|
||||
ba_obj.handle_blockage_migration(req)
|
||||
}
|
||||
}
|
||||
|
||||
// Generate and return an open invitation token
|
||||
pub fn generate_invite(context: LoxServerContext) -> Response<Body> {
|
||||
let invite = context.gen_invite();
|
||||
let token = serde_json::to_string(&invite).unwrap();
|
||||
prepare_header(token)
|
||||
match serde_json::to_string(&invite) {
|
||||
Ok(resp) => prepare_header(resp),
|
||||
Err(e) => {
|
||||
println!("Error parsing Invite to JSON");
|
||||
prepare_error_header(e.to_string())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Return the serialized encrypted bridge table
|
||||
pub fn send_reachability_cred(context: LoxServerContext) -> Response<Body> {
|
||||
let enc_table = context.encrypt_table();
|
||||
let etable = lox_utils::EncBridgeTable { etable: enc_table };
|
||||
prepare_header(serde_json::to_string(&etable).unwrap())
|
||||
match serde_json::to_string(&etable) {
|
||||
Ok(resp) => prepare_header(resp),
|
||||
Err(e) => {
|
||||
println!("Error parsing encrypted bridgetable to JSON");
|
||||
prepare_error_header(e.to_string())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Return the serialized pubkeys for the Bridge Authority
|
||||
pub fn send_keys(context: LoxServerContext) -> Response<Body> {
|
||||
let pubkeys = context.pubkeys();
|
||||
prepare_header(serde_json::to_string(&pubkeys).unwrap())
|
||||
match serde_json::to_string(&pubkeys) {
|
||||
Ok(resp) => prepare_header(resp),
|
||||
Err(e) => {
|
||||
println!("Error parsing Pubkeys to JSON");
|
||||
prepare_error_header(e.to_string())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn verify_and_send_open_cred(request: Bytes, context: LoxServerContext) -> Response<Body> {
|
||||
let req: open_invite::Request = serde_json::from_slice(&request).unwrap();
|
||||
let response = context.open_inv(req);
|
||||
let open_invite_resp_str = serde_json::to_string(&response).unwrap();
|
||||
prepare_header(open_invite_resp_str)
|
||||
let req = match serde_json::from_slice(&request) {
|
||||
Ok(req) => req,
|
||||
Err(e) => return prepare_error_header(e.to_string()),
|
||||
};
|
||||
match context.open_inv(req) {
|
||||
Ok(resp) => {
|
||||
let response = serde_json::to_string(&resp).unwrap();
|
||||
prepare_header(response)
|
||||
}
|
||||
Err(e) => {
|
||||
println!("Invalid Open Invitation request, Proof Error");
|
||||
prepare_error_header(e.to_string())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn verify_and_send_trust_promo(request: Bytes, context: LoxServerContext) -> Response<Body> {
|
||||
let req: trust_promotion::Request = serde_json::from_slice(&request).unwrap();
|
||||
let response = context.trust_promo(req);
|
||||
let trust_promo_resp_str = serde_json::to_string(&response).unwrap();
|
||||
prepare_header(trust_promo_resp_str)
|
||||
let req: trust_promotion::Request = match serde_json::from_slice(&request) {
|
||||
Ok(req) => req,
|
||||
Err(e) => return prepare_error_header(e.to_string()),
|
||||
};
|
||||
match context.trust_promo(req) {
|
||||
Ok(resp) => {
|
||||
let response = serde_json::to_string(&resp).unwrap();
|
||||
prepare_header(response)
|
||||
}
|
||||
Err(e) => {
|
||||
println!("Invalid Trust Promotion request, Proof Error");
|
||||
prepare_error_header(e.to_string())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn verify_and_send_trust_migration(
|
||||
request: Bytes,
|
||||
context: LoxServerContext,
|
||||
) -> Response<Body> {
|
||||
let req: migration::Request = serde_json::from_slice(&request).unwrap();
|
||||
let response = context.trust_migration(req);
|
||||
let resp_str = serde_json::to_string(&response).unwrap();
|
||||
prepare_header(resp_str)
|
||||
let req: migration::Request = match serde_json::from_slice(&request) {
|
||||
Ok(req) => req,
|
||||
Err(e) => return prepare_error_header(e.to_string()),
|
||||
};
|
||||
match context.trust_migration(req) {
|
||||
Ok(resp) => {
|
||||
let response = serde_json::to_string(&resp).unwrap();
|
||||
prepare_header(response)
|
||||
}
|
||||
Err(e) => {
|
||||
println!("Invalid Trust Migration request, Proof Error");
|
||||
prepare_error_header(e.to_string())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn verify_and_send_level_up(request: Bytes, context: LoxServerContext) -> Response<Body> {
|
||||
let req: level_up::Request = serde_json::from_slice(&request).unwrap();
|
||||
let response = context.level_up(req);
|
||||
let level_up_resp_str = serde_json::to_string(&response).unwrap();
|
||||
prepare_header(level_up_resp_str)
|
||||
let req: level_up::Request = match serde_json::from_slice(&request) {
|
||||
Ok(req) => req,
|
||||
Err(e) => return prepare_error_header(e.to_string()),
|
||||
};
|
||||
match context.level_up(req) {
|
||||
Ok(resp) => {
|
||||
let response = serde_json::to_string(&resp).unwrap();
|
||||
prepare_header(response)
|
||||
}
|
||||
Err(e) => {
|
||||
println!("Invalid Level up request, Proof Error");
|
||||
prepare_error_header(e.to_string())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn verify_and_send_issue_invite(request: Bytes, context: LoxServerContext) -> Response<Body> {
|
||||
let req: issue_invite::Request = serde_json::from_slice(&request).unwrap();
|
||||
let response = context.issue_invite(req);
|
||||
let issue_invite_resp_str = serde_json::to_string(&response).unwrap();
|
||||
prepare_header(issue_invite_resp_str)
|
||||
let req: issue_invite::Request = match serde_json::from_slice(&request) {
|
||||
Ok(req) => req,
|
||||
Err(e) => return prepare_error_header(e.to_string()),
|
||||
};
|
||||
match context.issue_invite(req) {
|
||||
Ok(resp) => {
|
||||
let response = serde_json::to_string(&resp).unwrap();
|
||||
prepare_header(response)
|
||||
}
|
||||
Err(e) => {
|
||||
println!("Invalid Issue invite request, Proof Error");
|
||||
prepare_error_header(e.to_string())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn verify_and_send_redeem_invite(request: Bytes, context: LoxServerContext) -> Response<Body> {
|
||||
let req: redeem_invite::Request = serde_json::from_slice(&request).unwrap();
|
||||
let response = context.redeem_invite(req);
|
||||
let redeem_invite_resp_str = serde_json::to_string(&response).unwrap();
|
||||
prepare_header(redeem_invite_resp_str)
|
||||
let req: redeem_invite::Request = match serde_json::from_slice(&request) {
|
||||
Ok(req) => req,
|
||||
Err(e) => return prepare_error_header(e.to_string()),
|
||||
};
|
||||
match context.redeem_invite(req) {
|
||||
Ok(resp) => {
|
||||
let response = serde_json::to_string(&resp).unwrap();
|
||||
prepare_header(response)
|
||||
}
|
||||
Err(e) => {
|
||||
println!("Invalid Redeem Invite request, Proof Error");
|
||||
prepare_error_header(e.to_string())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn verify_and_send_check_blockage(request: Bytes, context: LoxServerContext) -> Response<Body> {
|
||||
let req: check_blockage::Request = serde_json::from_slice(&request).unwrap();
|
||||
let response = context.check_blockage(req);
|
||||
let check_blockage_resp_str = serde_json::to_string(&response).unwrap();
|
||||
prepare_header(check_blockage_resp_str)
|
||||
let req: check_blockage::Request = match serde_json::from_slice(&request) {
|
||||
Ok(req) => req,
|
||||
Err(e) => return prepare_error_header(e.to_string()),
|
||||
};
|
||||
match context.check_blockage(req) {
|
||||
Ok(resp) => {
|
||||
let response = serde_json::to_string(&resp).unwrap();
|
||||
prepare_header(response)
|
||||
}
|
||||
Err(e) => {
|
||||
println!("Invalid Check blockage request, Proof Error");
|
||||
prepare_error_header(e.to_string())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn verify_and_send_blockage_migration(
|
||||
request: Bytes,
|
||||
context: LoxServerContext,
|
||||
) -> Response<Body> {
|
||||
let req: blockage_migration::Request = serde_json::from_slice(&request).unwrap();
|
||||
let response = context.blockage_migration(req);
|
||||
let resp_str = serde_json::to_string(&response).unwrap();
|
||||
prepare_header(resp_str)
|
||||
let req: blockage_migration::Request = match serde_json::from_slice(&request) {
|
||||
Ok(req) => req,
|
||||
Err(e) => return prepare_error_header(e.to_string()),
|
||||
};
|
||||
match context.blockage_migration(req) {
|
||||
Ok(resp) => {
|
||||
let response = serde_json::to_string(&resp).unwrap();
|
||||
prepare_header(response)
|
||||
}
|
||||
Err(e) => {
|
||||
println!("Invalid Blockage Migration request, Proof Error");
|
||||
prepare_error_header(e.to_string())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn prepare_header(response: String) -> Response<Body> {
|
||||
|
|
@ -248,3 +361,10 @@ fn prepare_header(response: String) -> Response<Body> {
|
|||
.insert("Access-Control-Allow-Origin", HeaderValue::from_static("*"));
|
||||
resp
|
||||
}
|
||||
|
||||
fn prepare_error_header(error: String) -> Response<Body> {
|
||||
Response::builder()
|
||||
.status(hyper::StatusCode::BAD_REQUEST)
|
||||
.body(Body::from(error))
|
||||
.unwrap()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -336,6 +336,15 @@ mod tests {
|
|||
let not_found_response = handle(th.context.clone(), four_oh_four_req).await.unwrap();
|
||||
assert_eq!(not_found_response.status(), StatusCode::NOT_FOUND);
|
||||
|
||||
// Test that empty request to a credential issuing endpoint fails
|
||||
let req = Request::builder()
|
||||
.method("POST")
|
||||
.uri("http://localhost/checkblockage")
|
||||
.body(Body::empty())
|
||||
.unwrap();
|
||||
let not_found_response = handle(th.context.clone(), req).await.unwrap();
|
||||
assert_eq!(not_found_response.status(), StatusCode::BAD_REQUEST);
|
||||
|
||||
// Test Invite
|
||||
let invite_request = lc.invite();
|
||||
let invite_response = handle(th.context.clone(), invite_request).await.unwrap();
|
||||
|
|
@ -616,7 +625,5 @@ mod tests {
|
|||
.await
|
||||
.unwrap();
|
||||
assert_eq!(blockagemig_response.status(), StatusCode::OK);
|
||||
|
||||
// Test Level up
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue