Better error handling, update for lox_cli

Cargo.toml

@@ -7,6 +7,7 @@ edition = "2021"
 
 [dependencies]
 aes-gcm = "0.10"
+anyhow = "1.0"
 array-bytes = "6.2.0"
 bincode = "1"
 chrono = "0.4"

src/bin/simulation.rs

@@ -141,7 +141,8 @@ pub async fn main() {
                     .unwrap()
                     .into(),
             )
-            .await;
+            .await
+            .unwrap();
         // Advance simulated time
         set_simulated_date(get_date() + UNTRUSTED_INTERVAL);
 
@@ -176,7 +177,8 @@ pub async fn main() {
                         .unwrap()
                         .into(),
                 )
-                .await;
+                .await
+                .unwrap();
             // Advance simulated time
             set_simulated_date(get_date() + LEVEL_INTERVAL[i]);
 
@@ -207,7 +209,8 @@ pub async fn main() {
                 "/advancedays".to_string(),
                 serde_json::to_string(&(1 as u16)).unwrap().into(),
             )
-            .await;
+            .await
+            .unwrap();
 
         // Advance simulated time to tomorrow
         increment_simulated_date();
@@ -366,10 +369,14 @@ pub async fn main() {
                 "/add".to_string(),
                 serde_json::to_string(&new_extra_infos).unwrap().into(),
             )
-            .await;
+            .await
+            .unwrap();
 
         // TROLL PATROL TASKS
-        let new_blockages_resp = tp_net_test.request("/update".to_string(), vec![]).await;
+        let new_blockages_resp = tp_net_test
+            .request("/update".to_string(), vec![])
+            .await
+            .unwrap();
         let new_blockages: HashMap<String, HashSet<String>> =
             serde_json::from_slice(&new_blockages_resp).unwrap();
 
@@ -415,7 +422,8 @@ pub async fn main() {
                 "/advancedays".to_string(),
                 serde_json::to_string(&(1 as u16)).unwrap().into(),
             )
-            .await;
+            .await
+            .unwrap();
 
         // SIMULATION TASKS
 

src/simulation/censor.rs

@@ -112,10 +112,15 @@ impl Censor {
             config.country.clone(),
         )
         .unwrap();
-        config
+        if config
             .tp_net
             .request("/positivereport".to_string(), pr.to_json().into_bytes())
-            .await;
+            .await
+            .is_err()
+        {
+            // failed to send positive report
+            return false;
+        }
         true
     }
 

src/simulation/user.rs

@@ -11,12 +11,12 @@ use crate::{
     },
     BridgeDistributor,
 };
+use anyhow::{anyhow, Result};
 use lox_cli::{networking::*, *};
 use lox_library::{
     bridge_table::BridgeLine, cred::Lox, proto::check_blockage::MIN_TRUST_LEVEL, scalar_u32,
 };
 use rand::Rng;
-use serde_json::error::Error;
 use std::{cmp::min, collections::HashMap};
 use x25519_dalek::PublicKey;
 
@@ -45,7 +45,7 @@ pub struct User {
 }
 
 impl User {
-    pub async fn new(config: &Config, is_censor: bool) -> Result<Self, Error> {
+    pub async fn new(config: &Config, is_censor: bool) -> Result<Self> {
         let cred = get_lox_credential(
             &config.la_net,
             &get_open_invitation(&config.la_net).await?,
@@ -75,7 +75,7 @@ impl User {
         })
     }
 
-    pub async fn trusted_user(config: &Config) -> Result<Self, Error> {
+    pub async fn trusted_user(config: &Config) -> Result<Self> {
         let cred = get_lox_credential(
             &config.la_net,
             &get_open_invitation(&config.la_net).await?,
@@ -98,7 +98,7 @@ impl User {
         config: &Config,
         censor: &mut Censor,
         invited_user_is_censor: bool,
-    ) -> Result<Self, Error> {
+    ) -> Result<Self> {
         let etable = get_reachability_credential(&config.la_net).await?;
         let (new_cred, invite) = issue_invite(
             &config.la_net,
@@ -205,7 +205,7 @@ impl User {
         true
     }
 
-    pub async fn get_new_credential(config: &Config) -> Result<(Lox, BridgeLine), Error> {
+    pub async fn get_new_credential(config: &Config) -> Result<(Lox, BridgeLine)> {
         get_lox_credential(
             &config.la_net,
             &get_open_invitation(&config.la_net).await?,
@@ -214,7 +214,10 @@ impl User {
         .await
     }
 
-    pub async fn send_negative_reports(config: &Config, reports: Vec<NegativeReport>) {
+    pub async fn send_negative_reports(
+        config: &Config,
+        reports: Vec<NegativeReport>,
+    ) -> Result<()> {
         let date = get_date();
         let pubkey = serde_json::from_slice::<Option<PublicKey>>(
             &config
@@ -223,9 +226,8 @@ impl User {
                     "/nrkey".to_string(),
                     serde_json::to_string(&date).unwrap().into(),
                 )
-                .await,
-        )
-        .unwrap()
+                .await?,
+        )?
         .unwrap();
         for report in reports {
             config
@@ -234,17 +236,22 @@ impl User {
                     "/negativereport".to_string(),
                     bincode::serialize(&report.encrypt(&pubkey)).unwrap(),
                 )
-                .await;
+                .await?;
         }
+        Ok(())
     }
 
-    pub async fn send_positive_reports(config: &Config, reports: Vec<PositiveReport>) {
+    pub async fn send_positive_reports(
+        config: &Config,
+        reports: Vec<PositiveReport>,
+    ) -> Result<()> {
         for report in reports {
             config
                 .tp_net
                 .request("/positivereport".to_string(), report.to_json().into_bytes())
-                .await;
+                .await?;
         }
+        Ok(())
     }
 
     pub async fn daily_tasks(
@@ -254,7 +261,7 @@ impl User {
         num_censor_invites: u32,
         bridges: &mut HashMap<[u8; 20], Bridge>,
         censor: &mut Censor,
-    ) -> Result<Vec<User>, Error> {
+    ) -> Result<Vec<User>> {
         if self.is_censor {
             self.daily_tasks_censor(config, bridges, censor).await
         } else {
@@ -280,14 +287,17 @@ impl User {
         num_censor_invites: u32,
         bridges: &mut HashMap<[u8; 20], Bridge>,
         censor: &mut Censor,
-    ) -> Result<Vec<User>, Error> {
+    ) -> Result<Vec<User>> {
         // Probabilistically decide if the user should use bridges today
         if event_happens(self.prob_use_bridges) {
             // Download bucket to see if bridge is still reachable. (We
             // assume that this step can be done even if the user can't
             // actually talk to the LA.)
             let (bucket, reachcred) = get_bucket(&config.la_net, &self.primary_cred).await?;
-            let level = scalar_u32(&self.primary_cred.trust_level).unwrap();
+            let level = match scalar_u32(&self.primary_cred.trust_level) {
+                Some(v) => v,
+                None => return Err(anyhow!("Failed to get trust level from credential")),
+            };
 
             // Make sure each bridge in bucket is in the global bridges set
             for bridgeline in bucket {
@@ -506,14 +516,17 @@ impl User {
             }
 
             if negative_reports.len() > 0 {
-                Self::send_negative_reports(&config, negative_reports).await;
+                Self::send_negative_reports(&config, negative_reports).await?;
             }
             if positive_reports.len() > 0 {
-                Self::send_positive_reports(&config, positive_reports).await;
+                Self::send_positive_reports(&config, positive_reports).await?;
             }
 
             // Invite friends if applicable
-            let invitations = scalar_u32(&self.primary_cred.invites_remaining).unwrap();
+            let invitations = match scalar_u32(&self.primary_cred.invites_remaining) {
+                Some(v) => v,
+                None => 0, // This is probably an error case that should not happen
+            };
             let mut new_friends = Vec::<User>::new();
             for _i in 0..min(invitations, num_users_requesting_invites) {
                 if event_happens(config.prob_user_invites_friend) {
@@ -561,7 +574,7 @@ impl User {
         config: &Config,
         bridges: &mut HashMap<[u8; 20], Bridge>,
         censor: &mut Censor,
-    ) -> Result<Vec<User>, Error> {
+    ) -> Result<Vec<User>> {
         // Download bucket to see if bridge is still reachable and if we
         // have any new bridges
         let (bucket, reachcred) = get_bucket(&config.la_net, &self.primary_cred).await?;