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

Add tests for varying percentages of blocked bridge

This commit is contained in:
onyinyang 2021-07-06 18:08:52 -04:00
parent 10959e1110
commit 2a6988e742
1 changed files with 248 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

275
crates/lox-library/src/tests.rs
View File

@ -4,7 +4,9 @@ BridgeLine::random() or private fields */
use super::bridge_table::BridgeLine;
use super::proto::*;
use super::*;
use rand::Rng;
use statistical::{mean, standard_deviation};
use std::collections::HashSet;
use std::time::{Duration, Instant};
struct PerfStat {
@ -84,7 +86,7 @@ impl TestHarness {
open_invite::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap();
let resp_handle_t = resp_handle_start.elapsed();
return (
(
PerfStat {
req_len,
resp_len,
@ -93,7 +95,7 @@ impl TestHarness {
resp_handle_t,
},
(cred, bridgeline),
);
)
}
fn trust_promotion(&mut self, cred: &cred::Lox) -> (PerfStat, cred::Migration) {
@ -116,7 +118,7 @@ impl TestHarness {
let migcred = trust_promotion::handle_response(promstate, decode_resp).unwrap();
let resp_handle_t = resp_handle_start.elapsed();
return (
(
PerfStat {
req_len,
resp_len,
@ -125,7 +127,7 @@ impl TestHarness {
resp_handle_t,
},
migcred,
);
)
}
fn level0_migration(
@ -152,7 +154,7 @@ impl TestHarness {
let cred = migration::handle_response(migstate, decode_resp, &self.ba.lox_pub).unwrap();
let resp_handle_t = resp_handle_start.elapsed();
return (
(
PerfStat {
req_len,
resp_len,
@ -161,7 +163,7 @@ impl TestHarness {
resp_handle_t,
},
cred,
);
)
}
fn level_up(&mut self, cred: &cred::Lox) -> (PerfStat, cred::Lox) {
@ -201,7 +203,7 @@ impl TestHarness {
let cred = level_up::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap();
let resp_handle_t = resp_handle_start.elapsed();
return (
(
PerfStat {
req_len,
resp_len,
@ -210,7 +212,7 @@ impl TestHarness {
resp_handle_t,
},
cred,
);
)
}
fn issue_invite(&mut self, cred: &cred::Lox) -> (PerfStat, (cred::Lox, cred::Invitation)) {
@ -253,7 +255,7 @@ impl TestHarness {
.unwrap();
let resp_handle_t = resp_handle_start.elapsed();
return (
(
PerfStat {
req_len,
resp_len,
@ -262,7 +264,7 @@ impl TestHarness {
resp_handle_t,
},
(cred, invite),
);
)
}
fn redeem_invite(&mut self, inv: &cred::Invitation) -> (PerfStat, cred::Lox) {
@ -285,7 +287,7 @@ impl TestHarness {
let cred = redeem_invite::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap();
let resp_handle_t = resp_handle_start.elapsed();
return (
(
PerfStat {
req_len,
resp_len,
@ -294,7 +296,7 @@ impl TestHarness {
resp_handle_t,
},
cred,
);
)
}
fn check_blockage(&mut self, cred: &cred::Lox) -> (PerfStat, cred::Migration) {
@ -316,7 +318,7 @@ impl TestHarness {
let migcred = check_blockage::handle_response(state, decode_resp).unwrap();
let resp_handle_t = resp_handle_start.elapsed();
return (
(
PerfStat {
req_len,
resp_len,
@ -325,7 +327,7 @@ impl TestHarness {
resp_handle_t,
},
migcred,
);
)
}
fn blockage_migration(
@ -355,7 +357,7 @@ impl TestHarness {
blockage_migration::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap();
let resp_handle_t = resp_handle_start.elapsed();
return (
(
PerfStat {
req_len,
resp_len,
@ -364,7 +366,7 @@ impl TestHarness {
resp_handle_t,
},
cred,
);
)
}
}
@ -936,8 +938,8 @@ fn stats_test_invitations() {
th.advance_days(14);
let (_, cred2) = th.level_up(&cred1);
th.advance_days(28);
let (perf_stat, (cred2a, invite)) = th.issue_invite(&cred2);
let (bob_perf_stat, bob_cred) = th.redeem_invite(&invite);
let (perf_stat, (_, invite)) = th.issue_invite(&cred2);
let (bob_perf_stat, _) = th.redeem_invite(&invite);
req_size.push(perf_stat.req_len as f64);
req_t_size.push(perf_stat.req_t.as_secs_f64());
resp_size.push(perf_stat.resp_len as f64);
@ -970,7 +972,203 @@ fn stats_test_invitations() {
}
#[test]
fn stats_test_blockage_migration() {
fn stats_test_blockage_migration_5() {
let mut th = TestHarness::new_buckets(10, 10);
let mut credentials: Vec<cred::Lox> = Vec::new();
for _ in 0..1000 {
let cred = th.open_invite().1 .0;
th.advance_days(30);
let (_, migcred) = th.trust_promotion(&cred);
let (_, cred1) = th.level0_migration(&cred, &migcred);
th.advance_days(14);
let (_, cred2) = th.level_up(&cred1);
let (_, (cred2a, invite)) = th.issue_invite(&cred2);
let (_, bob_cred) = th.redeem_invite(&invite);
th.advance_days(28);
let (_, _) = th.level_up(&bob_cred);
let (_, cred3) = th.level_up(&cred2a);
credentials.push(cred3);
}
block_bridges(&mut th, 5, credentials);
}
#[test]
fn stats_test_blockage_migration_10() {
let mut th = TestHarness::new_buckets(10, 10);
let mut credentials: Vec<cred::Lox> = Vec::new();
for _ in 0..1000 {
let cred = th.open_invite().1 .0;
th.advance_days(30);
let (_, migcred) = th.trust_promotion(&cred);
let (_, cred1) = th.level0_migration(&cred, &migcred);
th.advance_days(14);
let (_, cred2) = th.level_up(&cred1);
let (_, (cred2a, invite)) = th.issue_invite(&cred2);
let (_, bob_cred) = th.redeem_invite(&invite);
th.advance_days(28);
let (_, _) = th.level_up(&bob_cred);
let (_, cred3) = th.level_up(&cred2a);
credentials.push(cred3);
}
block_bridges(&mut th, 10, credentials);
}
#[test]
fn stats_test_blockage_migration_15() {
let mut th = TestHarness::new_buckets(10, 10);
let mut credentials: Vec<cred::Lox> = Vec::new();
for _ in 0..100 {
let cred = th.open_invite().1 .0;
th.advance_days(30);
let (_, migcred) = th.trust_promotion(&cred);
let (_, cred1) = th.level0_migration(&cred, &migcred);
th.advance_days(14);
let (_, cred2) = th.level_up(&cred1);
let (_, (cred2a, invite)) = th.issue_invite(&cred2);
let (_, bob_cred) = th.redeem_invite(&invite);
th.advance_days(28);
let (_, _) = th.level_up(&bob_cred);
let (_, cred3) = th.level_up(&cred2a);
credentials.push(cred3);
}
block_bridges(&mut th, 15, credentials);
}
#[test]
fn stats_test_blockage_migration_20() {
let mut th = TestHarness::new_buckets(10, 10);
let mut credentials: Vec<cred::Lox> = Vec::new();
for _ in 0..100 {
let cred = th.open_invite().1 .0;
th.advance_days(30);
let (_, migcred) = th.trust_promotion(&cred);
let (_, cred1) = th.level0_migration(&cred, &migcred);
th.advance_days(14);
let (_, cred2) = th.level_up(&cred1);
let (_, (cred2a, invite)) = th.issue_invite(&cred2);
let (_, bob_cred) = th.redeem_invite(&invite);
th.advance_days(28);
let (_, _) = th.level_up(&bob_cred);
let (_, cred3) = th.level_up(&cred2a);
credentials.push(cred3);
}
block_bridges(&mut th, 20, credentials);
}
#[test]
fn stats_test_blockage_migration_25() {
let mut th = TestHarness::new_buckets(10, 10);
let mut credentials: Vec<cred::Lox> = Vec::new();
for _ in 0..100 {
let cred = th.open_invite().1 .0;
th.advance_days(30);
let (_, migcred) = th.trust_promotion(&cred);
let (_, cred1) = th.level0_migration(&cred, &migcred);
th.advance_days(14);
let (_, cred2) = th.level_up(&cred1);
let (_, (cred2a, invite)) = th.issue_invite(&cred2);
let (_, bob_cred) = th.redeem_invite(&invite);
th.advance_days(28);
let (_, _) = th.level_up(&bob_cred);
let (_, cred3) = th.level_up(&cred2a);
credentials.push(cred3);
}
block_bridges(&mut th, 25, credentials);
}
#[test]
fn stats_test_blockage_migration_30() {
let mut th = TestHarness::new_buckets(10, 10);
let mut credentials: Vec<cred::Lox> = Vec::new();
for _ in 0..100 {
let cred = th.open_invite().1 .0;
th.advance_days(30);
let (_, migcred) = th.trust_promotion(&cred);
let (_, cred1) = th.level0_migration(&cred, &migcred);
th.advance_days(14);
let (_, cred2) = th.level_up(&cred1);
let (_, (cred2a, invite)) = th.issue_invite(&cred2);
let (_, bob_cred) = th.redeem_invite(&invite);
th.advance_days(28);
let (_, _) = th.level_up(&bob_cred);
let (_, cred3) = th.level_up(&cred2a);
credentials.push(cred3);
}
block_bridges(&mut th, 30, credentials);
}
#[test]
fn stats_test_blockage_migration_35() {
let mut th = TestHarness::new_buckets(10, 10);
let mut credentials: Vec<cred::Lox> = Vec::new();
for _ in 0..100 {
let cred = th.open_invite().1 .0;
th.advance_days(30);
let (_, migcred) = th.trust_promotion(&cred);
let (_, cred1) = th.level0_migration(&cred, &migcred);
th.advance_days(14);
let (_, cred2) = th.level_up(&cred1);
let (_, (cred2a, invite)) = th.issue_invite(&cred2);
let (_, bob_cred) = th.redeem_invite(&invite);
th.advance_days(28);
let (_, _) = th.level_up(&bob_cred);
let (_, cred3) = th.level_up(&cred2a);
credentials.push(cred3);
}
block_bridges(&mut th, 35, credentials);
}
#[test]
fn stats_test_blockage_migration_40() {
let mut th = TestHarness::new_buckets(10, 10);
let mut credentials: Vec<cred::Lox> = Vec::new();
for _ in 0..100 {
let cred = th.open_invite().1 .0;
th.advance_days(30);
let (_, migcred) = th.trust_promotion(&cred);
let (_, cred1) = th.level0_migration(&cred, &migcred);
th.advance_days(14);
let (_, cred2) = th.level_up(&cred1);
let (_, (cred2a, invite)) = th.issue_invite(&cred2);
let (_, bob_cred) = th.redeem_invite(&invite);
th.advance_days(28);
let (_, _) = th.level_up(&bob_cred);
let (_, cred3) = th.level_up(&cred2a);
credentials.push(cred3);
}
block_bridges(&mut th, 40, credentials);
}
/// Blocks a percentage of the total number of bridges for the passed Test Harness
/// for the number of buckets and hot spares passed at initialization
fn block_bridges(th: &mut TestHarness, percentage: usize, credentials: Vec<cred::Lox>) {
let to_block: usize = (th.ba.bridge_table.buckets.len() * percentage / 100).into();
let mut block_index: HashSet<usize> = HashSet::new();
let mut rng = rand::thread_rng();
while block_index.len() <= to_block - 1 {
let rand_num = rng.gen_range(0, th.ba.bridge_table.buckets.len());
block_index.insert(rand_num);
}
for index in block_index {
let b0 = th.ba.bridge_table.buckets[index][0];
let b1 = th.ba.bridge_table.buckets[index][1];
let b2 = th.ba.bridge_table.buckets[index][2];
th.ba.bridge_unreachable(&b0, &mut th.bdb);
th.ba.bridge_unreachable(&b1, &mut th.bdb);
th.ba.bridge_unreachable(&b2, &mut th.bdb);
}
let mut req_size: Vec<f64> = Vec::new();
let mut resp_size: Vec<f64> = Vec::new();
let mut req_t_size: Vec<f64> = Vec::new();
@ -981,26 +1179,22 @@ fn stats_test_blockage_migration() {
let mut red_req_t_size: Vec<f64> = Vec::new();
let mut red_resp_t_size: Vec<f64> = Vec::new();
let mut red_resp_handle_t_size: Vec<f64> = Vec::new();
for _ in 0..10000 {
let mut th = TestHarness::new_buckets(3, 3);
let cred = th.open_invite().1 .0;
th.advance_days(30);
let (_, migcred) = th.trust_promotion(&cred);
let (_, cred1) = th.level0_migration(&cred, &migcred);
th.advance_days(14);
let (_, cred2) = th.level_up(&cred1);
th.advance_days(28);
let (_, cred3) = th.level_up(&cred2);
let (id, key) = bridge_table::from_scalar(cred3.bucket).unwrap();
for cred in credentials {
let (id, key) = bridge_table::from_scalar(cred.bucket).unwrap();
let encbuckets = th.ba.enc_bridge_table();
let bucket =
bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets[id as usize]).unwrap();
th.ba.bridge_unreachable(&bucket.0[0], &mut th.bdb);
th.ba.bridge_unreachable(&bucket.0[1], &mut th.bdb);
th.ba.bridge_unreachable(&bucket.0[2], &mut th.bdb);
let (perf_stat, migration) = th.check_blockage(&cred3);
let (block_perf_stat, cred4) = th.blockage_migration(&cred3, &migration);
let mut count = 0;
for bridge_line in &bucket.0 {
if th.ba.bridge_table.reachable.contains_key(bridge_line) {
count = count + 1;
}
}
if count < 2 {
let (perf_stat, migration) = th.check_blockage(&cred);
let (block_perf_stat, _) = th.blockage_migration(&cred, &migration);
req_size.push(perf_stat.req_len as f64);
req_t_size.push(perf_stat.req_t.as_secs_f64());
resp_size.push(perf_stat.resp_len as f64);
@ -1012,8 +1206,12 @@ fn stats_test_blockage_migration() {
red_resp_t_size.push(block_perf_stat.resp_t.as_secs_f64());
red_resp_handle_t_size.push(block_perf_stat.resp_handle_t.as_secs_f64());
}
}
println!("\n---------------Check Blockage----------------\n");
println!(
"\n---------------Check Blockage {}---------------\n",
percentage
);
print_stats_test_results(
req_size,
req_t_size,
@ -1022,7 +1220,10 @@ fn stats_test_blockage_migration() {
resp_handle_t_size,
);
println!("\n---------------Blockage Migration----------------\n");
println!(
"\n---------------Blockage Migration {}---------------\n",
percentage
);
print_stats_test_results(
red_req_size,
red_req_t_size,