Reformat lox context to include request handling fns
This commit is contained in:
onyinyang
parent
39577b95ca
commit
2bb043b6b8
|
|
@ -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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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<Body> {
|
||||
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())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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};
|
||||
|
|
|
|||
Loading…
Reference in New Issue