vecna
/
lox
mirror of https://gitlab.torproject.org/vecna/lox.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Reformat lox context to include request handling fns

This commit is contained in:
onyinyang 2023-08-30 18:40:38 -04:00
parent 39577b95ca
commit 2bb043b6b8
No known key found for this signature in database
GPG Key ID: 156A6435430C2036
2 changed files with 153 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
crates/lox-distributor/src/lox_context.rs
View File

@ -200,11 +200,10 @@ impl LoxServerContext {
let mut ba_obj = self.ba.lock().unwrap(); let mut ba_obj = self.ba.lock().unwrap();
ba_obj.handle_blockage_migration(req) ba_obj.handle_blockage_migration(req)
} }
}
// Generate and return an open invitation token // Generate and return an open invitation token
pub fn generate_invite(context: LoxServerContext) -> Response<Body> { pub fn generate_invite(self) -> Response<Body> {
let invite = context.gen_invite(); let invite = self.gen_invite();
match serde_json::to_string(&invite) { match serde_json::to_string(&invite) {
Ok(resp) => prepare_header(resp), Ok(resp) => prepare_header(resp),
Err(e) => { Err(e) => {
@ -215,8 +214,8 @@ pub fn generate_invite(context: LoxServerContext) -> Response<Body> {
} }
// Return the serialized encrypted bridge table // Return the serialized encrypted bridge table
pub fn send_reachability_cred(context: LoxServerContext) -> Response<Body> { pub fn send_reachability_cred(self) -> Response<Body> {
let enc_table = context.encrypt_table(); let enc_table = self.encrypt_table();
let etable = lox_utils::EncBridgeTable { etable: enc_table }; let etable = lox_utils::EncBridgeTable { etable: enc_table };
match serde_json::to_string(&etable) { match serde_json::to_string(&etable) {
Ok(resp) => prepare_header(resp), Ok(resp) => prepare_header(resp),
@ -228,8 +227,8 @@ pub fn send_reachability_cred(context: LoxServerContext) -> Response<Body> {
} }
// Return the serialized pubkeys for the Bridge Authority // Return the serialized pubkeys for the Bridge Authority
pub fn send_keys(context: LoxServerContext) -> Response<Body> { pub fn send_keys(self) -> Response<Body> {
let pubkeys = context.pubkeys(); let pubkeys = self.pubkeys();
match serde_json::to_string(&pubkeys) { match serde_json::to_string(&pubkeys) {
Ok(resp) => prepare_header(resp), Ok(resp) => prepare_header(resp),
Err(e) => { Err(e) => {
@ -239,12 +238,12 @@ pub fn send_keys(context: LoxServerContext) -> Response<Body> {
} }
} }
pub fn verify_and_send_open_cred(request: Bytes, context: LoxServerContext) -> Response<Body> { pub fn verify_and_send_open_cred(self, request: Bytes) -> Response<Body> {
let req = match serde_json::from_slice(&request) { let req = match serde_json::from_slice(&request) {
Ok(req) => req, Ok(req) => req,
Err(e) => return prepare_error_header(e.to_string()), Err(e) => return prepare_error_header(e.to_string()),
}; };
match context.open_inv(req) { match self.open_inv(req) {
Ok(resp) => { Ok(resp) => {
let response = serde_json::to_string(&resp).unwrap(); let response = serde_json::to_string(&resp).unwrap();
prepare_header(response) prepare_header(response)
@ -256,12 +255,12 @@ pub fn verify_and_send_open_cred(request: Bytes, context: LoxServerContext) -> R
} }
} }
pub fn verify_and_send_trust_promo(request: Bytes, context: LoxServerContext) -> Response<Body> { pub fn verify_and_send_trust_promo(self, request: Bytes) -> Response<Body> {
let req: trust_promotion::Request = match serde_json::from_slice(&request) { let req: trust_promotion::Request = match serde_json::from_slice(&request) {
Ok(req) => req, Ok(req) => req,
Err(e) => return prepare_error_header(e.to_string()), Err(e) => return prepare_error_header(e.to_string()),
}; };
match context.trust_promo(req) { match self.trust_promo(req) {
Ok(resp) => { Ok(resp) => {
let response = serde_json::to_string(&resp).unwrap(); let response = serde_json::to_string(&resp).unwrap();
prepare_header(response) prepare_header(response)
@ -273,15 +272,12 @@ pub fn verify_and_send_trust_promo(request: Bytes, context: LoxServerContext) ->
} }
} }
pub fn verify_and_send_trust_migration( pub fn verify_and_send_trust_migration(self, request: Bytes) -> Response<Body> {
request: Bytes,
context: LoxServerContext,
) -> Response<Body> {
let req: migration::Request = match serde_json::from_slice(&request) { let req: migration::Request = match serde_json::from_slice(&request) {
Ok(req) => req, Ok(req) => req,
Err(e) => return prepare_error_header(e.to_string()), Err(e) => return prepare_error_header(e.to_string()),
}; };
match context.trust_migration(req) { match self.trust_migration(req) {
Ok(resp) => { Ok(resp) => {
let response = serde_json::to_string(&resp).unwrap(); let response = serde_json::to_string(&resp).unwrap();
prepare_header(response) prepare_header(response)
@ -293,12 +289,12 @@ pub fn verify_and_send_trust_migration(
} }
} }
pub fn verify_and_send_level_up(request: Bytes, context: LoxServerContext) -> Response<Body> { pub fn verify_and_send_level_up(self, request: Bytes) -> Response<Body> {
let req: level_up::Request = match serde_json::from_slice(&request) { let req: level_up::Request = match serde_json::from_slice(&request) {
Ok(req) => req, Ok(req) => req,
Err(e) => return prepare_error_header(e.to_string()), Err(e) => return prepare_error_header(e.to_string()),
}; };
match context.level_up(req) { match self.level_up(req) {
Ok(resp) => { Ok(resp) => {
let response = serde_json::to_string(&resp).unwrap(); let response = serde_json::to_string(&resp).unwrap();
prepare_header(response) prepare_header(response)
@ -310,12 +306,12 @@ pub fn verify_and_send_level_up(request: Bytes, context: LoxServerContext) -> Re
} }
} }
pub fn verify_and_send_issue_invite(request: Bytes, context: LoxServerContext) -> Response<Body> { pub fn verify_and_send_issue_invite(self, request: Bytes) -> Response<Body> {
let req: issue_invite::Request = match serde_json::from_slice(&request) { let req: issue_invite::Request = match serde_json::from_slice(&request) {
Ok(req) => req, Ok(req) => req,
Err(e) => return prepare_error_header(e.to_string()), Err(e) => return prepare_error_header(e.to_string()),
}; };
match context.issue_invite(req) { match self.issue_invite(req) {
Ok(resp) => { Ok(resp) => {
let response = serde_json::to_string(&resp).unwrap(); let response = serde_json::to_string(&resp).unwrap();
prepare_header(response) prepare_header(response)
@ -327,12 +323,12 @@ pub fn verify_and_send_issue_invite(request: Bytes, context: LoxServerContext) -
} }
} }
pub fn verify_and_send_redeem_invite(request: Bytes, context: LoxServerContext) -> Response<Body> { pub fn verify_and_send_redeem_invite(self, request: Bytes) -> Response<Body> {
let req: redeem_invite::Request = match serde_json::from_slice(&request) { let req: redeem_invite::Request = match serde_json::from_slice(&request) {
Ok(req) => req, Ok(req) => req,
Err(e) => return prepare_error_header(e.to_string()), Err(e) => return prepare_error_header(e.to_string()),
}; };
match context.redeem_invite(req) { match self.redeem_invite(req) {
Ok(resp) => { Ok(resp) => {
let response = serde_json::to_string(&resp).unwrap(); let response = serde_json::to_string(&resp).unwrap();
prepare_header(response) prepare_header(response)
@ -344,12 +340,12 @@ pub fn verify_and_send_redeem_invite(request: Bytes, context: LoxServerContext)
} }
} }
pub fn verify_and_send_check_blockage(request: Bytes, context: LoxServerContext) -> Response<Body> { pub fn verify_and_send_check_blockage(self, request: Bytes) -> Response<Body> {
let req: check_blockage::Request = match serde_json::from_slice(&request) { let req: check_blockage::Request = match serde_json::from_slice(&request) {
Ok(req) => req, Ok(req) => req,
Err(e) => return prepare_error_header(e.to_string()), Err(e) => return prepare_error_header(e.to_string()),
}; };
match context.check_blockage(req) { match self.check_blockage(req) {
Ok(resp) => { Ok(resp) => {
let response = serde_json::to_string(&resp).unwrap(); let response = serde_json::to_string(&resp).unwrap();
prepare_header(response) prepare_header(response)
@ -361,15 +357,12 @@ pub fn verify_and_send_check_blockage(request: Bytes, context: LoxServerContext)
} }
} }
pub fn verify_and_send_blockage_migration( pub fn verify_and_send_blockage_migration(self, request: Bytes) -> Response<Body> {
request: Bytes,
context: LoxServerContext,
) -> Response<Body> {
let req: blockage_migration::Request = match serde_json::from_slice(&request) { let req: blockage_migration::Request = match serde_json::from_slice(&request) {
Ok(req) => req, Ok(req) => req,
Err(e) => return prepare_error_header(e.to_string()), Err(e) => return prepare_error_header(e.to_string()),
}; };
match context.blockage_migration(req) { match self.blockage_migration(req) {
Ok(resp) => { Ok(resp) => {
let response = serde_json::to_string(&resp).unwrap(); let response = serde_json::to_string(&resp).unwrap();
prepare_header(response) prepare_header(response)
@ -380,6 +373,7 @@ pub fn verify_and_send_blockage_migration(
} }
} }
} }
}
fn prepare_header(response: String) -> Response<Body> { fn prepare_header(response: String) -> Response<Body> {
let mut resp = Response::new(Body::from(response)); let mut resp = Response::new(Body::from(response));

29
crates/lox-distributor/src/request_handler.rs
View File

@ -1,4 +1,3 @@
use crate::lox_context;
use crate::lox_context::LoxServerContext; use crate::lox_context::LoxServerContext;
use hyper::{body, header::HeaderValue, Body, Method, Request, Response, StatusCode}; use hyper::{body, header::HeaderValue, Body, Method, Request, Response, StatusCode};
use std::convert::Infallible; use std::convert::Infallible;
@ -17,47 +16,43 @@ pub async fn handle(
.body(Body::from("Allow POST")) .body(Body::from("Allow POST"))
.unwrap()), .unwrap()),
_ => match (req.method(), req.uri().path()) { _ => match (req.method(), req.uri().path()) {
(&Method::POST, "/invite") => { (&Method::POST, "/invite") => Ok::<_, Infallible>(cloned_context.generate_invite()),
Ok::<_, Infallible>(lox_context::generate_invite(cloned_context))
}
(&Method::POST, "/reachability") => { (&Method::POST, "/reachability") => {
Ok::<_, Infallible>(lox_context::send_reachability_cred(cloned_context)) Ok::<_, Infallible>(cloned_context.send_reachability_cred())
}
(&Method::POST, "/pubkeys") => {
Ok::<_, Infallible>(lox_context::send_keys(cloned_context))
} }
(&Method::POST, "/pubkeys") => Ok::<_, Infallible>(cloned_context.send_keys()),
(&Method::POST, "/openreq") => Ok::<_, Infallible>({ (&Method::POST, "/openreq") => Ok::<_, Infallible>({
let bytes = body::to_bytes(req.into_body()).await.unwrap(); 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>({ (&Method::POST, "/trustpromo") => Ok::<_, Infallible>({
let bytes = body::to_bytes(req.into_body()).await.unwrap(); 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>({ (&Method::POST, "/trustmig") => Ok::<_, Infallible>({
let bytes = body::to_bytes(req.into_body()).await.unwrap(); 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>({ (&Method::POST, "/levelup") => Ok::<_, Infallible>({
let bytes = body::to_bytes(req.into_body()).await.unwrap(); 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>({ (&Method::POST, "/issueinvite") => Ok::<_, Infallible>({
let bytes = body::to_bytes(req.into_body()).await.unwrap(); 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>({ (&Method::POST, "/redeem") => Ok::<_, Infallible>({
let bytes = body::to_bytes(req.into_body()).await.unwrap(); 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>({ (&Method::POST, "/checkblockage") => Ok::<_, Infallible>({
let bytes = body::to_bytes(req.into_body()).await.unwrap(); let bytes = body::to_bytes(req.into_body()).await.unwrap();
// TEST ONLY: Block all existing bridges and add new ones for migration // 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>({ (&Method::POST, "/blockagemigration") => Ok::<_, Infallible>({
let bytes = body::to_bytes(req.into_body()).await.unwrap(); 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. // Return 404 not found response.
@ -72,6 +67,8 @@ pub async fn handle(
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::lox_context;
use super::*; use super::*;
use chrono::{Duration, Utc}; use chrono::{Duration, Utc};