From 2bb043b6b856fba59959e5aa1e8691fd66781106 Mon Sep 17 00:00:00 2001 From: onyinyang Date: Wed, 30 Aug 2023 18:40:38 -0400 Subject: [PATCH] Reformat lox context to include request handling fns --- crates/lox-distributor/src/lox_context.rs | 286 +++++++++--------- crates/lox-distributor/src/request_handler.rs | 29 +- 2 files changed, 153 insertions(+), 162 deletions(-) diff --git a/crates/lox-distributor/src/lox_context.rs b/crates/lox-distributor/src/lox_context.rs index 50a6696..b732880 100644 --- a/crates/lox-distributor/src/lox_context.rs +++ b/crates/lox-distributor/src/lox_context.rs @@ -200,183 +200,177 @@ impl LoxServerContext { let mut ba_obj = self.ba.lock().unwrap(); ba_obj.handle_blockage_migration(req) } -} -// Generate and return an open invitation token -pub fn generate_invite(context: LoxServerContext) -> Response { - let invite = context.gen_invite(); - 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()) + // Generate and return an open invitation token + pub fn generate_invite(self) -> Response { + let invite = self.gen_invite(); + 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 { - let enc_table = context.encrypt_table(); - let etable = lox_utils::EncBridgeTable { etable: enc_table }; - 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 encrypted bridge table + pub fn send_reachability_cred(self) -> Response { + let enc_table = self.encrypt_table(); + let etable = lox_utils::EncBridgeTable { etable: enc_table }; + 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 { - let pubkeys = context.pubkeys(); - 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()) + // Return the serialized pubkeys for the Bridge Authority + pub fn send_keys(self) -> Response { + let pubkeys = self.pubkeys(); + 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 { - 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_open_cred(self, request: Bytes) -> Response { + let req = match serde_json::from_slice(&request) { + Ok(req) => req, + Err(e) => return prepare_error_header(e.to_string()), + }; + match self.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 { - 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_promo(self, request: Bytes) -> Response { + let req: trust_promotion::Request = match serde_json::from_slice(&request) { + Ok(req) => req, + Err(e) => return prepare_error_header(e.to_string()), + }; + match self.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 { - 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_trust_migration(self, request: Bytes) -> Response { + let req: migration::Request = match serde_json::from_slice(&request) { + Ok(req) => req, + Err(e) => return prepare_error_header(e.to_string()), + }; + match self.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 { - 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_level_up(self, request: Bytes) -> Response { + let req: level_up::Request = match serde_json::from_slice(&request) { + Ok(req) => req, + Err(e) => return prepare_error_header(e.to_string()), + }; + match self.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 { - 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_issue_invite(self, request: Bytes) -> Response { + let req: issue_invite::Request = match serde_json::from_slice(&request) { + Ok(req) => req, + Err(e) => return prepare_error_header(e.to_string()), + }; + match self.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 { - 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_redeem_invite(self, request: Bytes) -> Response { + let req: redeem_invite::Request = match serde_json::from_slice(&request) { + Ok(req) => req, + Err(e) => return prepare_error_header(e.to_string()), + }; + match self.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 { - 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_check_blockage(self, request: Bytes) -> Response { + let req: check_blockage::Request = match serde_json::from_slice(&request) { + Ok(req) => req, + Err(e) => return prepare_error_header(e.to_string()), + }; + match self.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 { - 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()) + pub fn verify_and_send_blockage_migration(self, request: Bytes) -> Response { + let req: blockage_migration::Request = match serde_json::from_slice(&request) { + Ok(req) => req, + Err(e) => return prepare_error_header(e.to_string()), + }; + match self.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()) + } } } } diff --git a/crates/lox-distributor/src/request_handler.rs b/crates/lox-distributor/src/request_handler.rs index 5416b36..c236a52 100644 --- a/crates/lox-distributor/src/request_handler.rs +++ b/crates/lox-distributor/src/request_handler.rs @@ -1,4 +1,3 @@ -use crate::lox_context; use crate::lox_context::LoxServerContext; use hyper::{body, header::HeaderValue, Body, Method, Request, Response, StatusCode}; use std::convert::Infallible; @@ -17,47 +16,43 @@ pub async fn handle( .body(Body::from("Allow POST")) .unwrap()), _ => match (req.method(), req.uri().path()) { - (&Method::POST, "/invite") => { - Ok::<_, Infallible>(lox_context::generate_invite(cloned_context)) - } + (&Method::POST, "/invite") => Ok::<_, Infallible>(cloned_context.generate_invite()), (&Method::POST, "/reachability") => { - Ok::<_, Infallible>(lox_context::send_reachability_cred(cloned_context)) - } - (&Method::POST, "/pubkeys") => { - Ok::<_, Infallible>(lox_context::send_keys(cloned_context)) + Ok::<_, Infallible>(cloned_context.send_reachability_cred()) } + (&Method::POST, "/pubkeys") => Ok::<_, Infallible>(cloned_context.send_keys()), (&Method::POST, "/openreq") => Ok::<_, Infallible>({ let bytes = body::to_bytes(req.into_body()).await.unwrap(); - lox_context::verify_and_send_open_cred(bytes, cloned_context) + cloned_context.verify_and_send_open_cred(bytes) }), (&Method::POST, "/trustpromo") => Ok::<_, Infallible>({ let bytes = body::to_bytes(req.into_body()).await.unwrap(); - lox_context::verify_and_send_trust_promo(bytes, cloned_context) + cloned_context.verify_and_send_trust_promo(bytes) }), (&Method::POST, "/trustmig") => Ok::<_, Infallible>({ let bytes = body::to_bytes(req.into_body()).await.unwrap(); - lox_context::verify_and_send_trust_migration(bytes, cloned_context) + cloned_context.verify_and_send_trust_migration(bytes) }), (&Method::POST, "/levelup") => Ok::<_, Infallible>({ let bytes = body::to_bytes(req.into_body()).await.unwrap(); - lox_context::verify_and_send_level_up(bytes, cloned_context) + cloned_context.verify_and_send_level_up(bytes) }), (&Method::POST, "/issueinvite") => Ok::<_, Infallible>({ let bytes = body::to_bytes(req.into_body()).await.unwrap(); - lox_context::verify_and_send_issue_invite(bytes, cloned_context) + cloned_context.verify_and_send_issue_invite(bytes) }), (&Method::POST, "/redeem") => Ok::<_, Infallible>({ let bytes = body::to_bytes(req.into_body()).await.unwrap(); - lox_context::verify_and_send_redeem_invite(bytes, cloned_context) + cloned_context.verify_and_send_redeem_invite(bytes) }), (&Method::POST, "/checkblockage") => Ok::<_, Infallible>({ let bytes = body::to_bytes(req.into_body()).await.unwrap(); // TEST ONLY: Block all existing bridges and add new ones for migration - lox_context::verify_and_send_check_blockage(bytes, cloned_context) + cloned_context.verify_and_send_check_blockage(bytes) }), (&Method::POST, "/blockagemigration") => Ok::<_, Infallible>({ let bytes = body::to_bytes(req.into_body()).await.unwrap(); - lox_context::verify_and_send_blockage_migration(bytes, cloned_context) + cloned_context.verify_and_send_blockage_migration(bytes) }), _ => { // Return 404 not found response. @@ -72,6 +67,8 @@ pub async fn handle( #[cfg(test)] mod tests { + use crate::lox_context; + use super::*; use chrono::{Duration, Utc};