Changed many unwraps to more meaningful errors

Author: ddd-mtl

crates/common/src/attachment.rs

@@ -17,7 +17,7 @@ pub fn write_attachment(conductor: ConductorHandle, filepath: PathBuf) -> Result
    } else { "__no_filename_found_".to_string() };
    let mut file = std::fs::File::open(filepath.clone())?;
    /// Get metadata and check size
-   let file_meta = file.metadata().unwrap();
+   let file_meta = file.metadata().expect("File should always have metadata");
    if file_meta.len() > FILE_MAX_SIZE as u64 {
       return Err(std::io::Error::new(std::io::ErrorKind::Other, "Attachment too big!"));
    }
@@ -57,7 +57,8 @@ pub fn write_attachment(conductor: ConductorHandle, filepath: PathBuf) -> Result
          chunk_index: i,
          chunk: chunk_b64,
       };
-      let hh = snapmail_write_chunk(conductor.clone(), WriteChunkInput(chunk_input)).unwrap();
+      let hh = snapmail_write_chunk(conductor.clone(), WriteChunkInput(chunk_input))
+         .map_err(|_err| std::io::Error::from(std::io::ErrorKind::Other))?;
       chunk_hh_list.push(hh);
       i += 1;
    }
@@ -70,13 +71,15 @@ pub fn write_attachment(conductor: ConductorHandle, filepath: PathBuf) -> Result
       orig_filesize: file_meta.len() as usize,
       chunks: chunk_hh_list,
    };
-   let res = snapmail_write_manifest(conductor, input).unwrap();
+   let res = snapmail_write_manifest(conductor, input)
+      .map_err(|_err| std::io::Error::from(std::io::ErrorKind::Other))?;
    Ok(res)
 }
 
 ///
 pub fn get_attachment(conductor: ConductorHandle, eh: EntryHash, path: PathBuf) -> std::io::Result<PathBuf> {
-   let manifest = snapmail_get_manifest(conductor.clone(), AnyDhtHash::from(eh)).unwrap();
+   let manifest = snapmail_get_manifest(conductor.clone(), AnyDhtHash::from(eh))
+      .map_err(|_err| std::io::Error::from(std::io::ErrorKind::Other))?;
 
    // /// Print
    // msg!("  Filename: {}", manifest.filename);

crates/common/src/conductor.rs

@@ -33,10 +33,10 @@ pub async fn start_conductor_or_abort(sid: String) -> (ConductorHandle, DnaHash)
    /// - Get UID
    let path = CONFIG_PATH.as_path().join(sid.clone());
    let app_filepath = path.join(APP_CONFIG_FILENAME);
-   let uid = std::fs::read_to_string(app_filepath).unwrap();
+   let uid = std::fs::read_to_string(app_filepath).expect("Should have config folder");
    let expected_hash = load_dna_from_rs(uid).await.dna_hash().clone();
    /// - Get Installed DNAs
-   let dnas = conductor.list_dnas().await.unwrap();
+   let dnas = conductor.list_dnas().await.expect("Conductor should not fail");
    /// - Check
    if dnas.len() != 1 {
       err_msg!("No installed DNA found ({})", dnas.len());
@@ -137,7 +137,7 @@ pub async fn install_app(sid: String, uid: String) -> ConductorResult<DnaHash> {
    /// Activate app
    conductor.activate_app(SNAPMAIL_APP_ID.to_string()).await?;
    /// Done
-   let dnas = conductor.list_dnas().await.unwrap();
+   let dnas = conductor.list_dnas().await.expect("Conductor should not fail");
    msg!("Installed DNAs: {:?}", dnas);
    Ok(dna_file.dna_hash().clone())
 }
@@ -148,7 +148,9 @@ pub fn dump_state(conductor: ConductorHandle) -> usize {
       //let p2p = conductor.holochain_p2p();
       //let broadcaster = conductor.signal_broadcaster();
 
-      let cell_id = &conductor.list_cell_ids().await.unwrap()[0];
+      let cell_id = &conductor.list_cell_ids().await
+         .expect("Conductor should not fail")
+         [0];
 
       // let cell = conductor.cell_by_id(cell_id).unwrap();
       // let arc = cell.env();
@@ -159,7 +161,7 @@ pub fn dump_state(conductor: ConductorHandle) -> usize {
       let peer_dump = p2p_store::dump_state(
          conductor.get_p2p_env().await.clone().into(),
          Some(cell_id.clone()),
-      ).unwrap();
+      ).expect("p2p_store should not fail");
 
       //let state = conductor.dump_cell_state(&cell_ids[0]).await.unwrap();
       //msg!(" {}", state);
@@ -169,5 +171,5 @@ pub fn dump_state(conductor: ConductorHandle) -> usize {
       // msg!(" - Peers: {}", peer_dump.peers.len());
       peer_dump.peers.len()
    }, std::time::Duration::from_secs(9));
-   result.unwrap()
+   result.expect("dump_state() should not fail")
 }

crates/common/src/config.rs

@@ -19,7 +19,8 @@ pub fn create_config(environment_path: PathBuf) -> ConductorConfig {
 /// Write [`ConductorConfig`] to [`CONDUCTOR_CONFIG`]
 pub fn write_config(mut path: PathBuf, config: &ConductorConfig) -> PathBuf {
     path.push(CONDUCTOR_CONFIG_FILENAME);
-    std::fs::write(path.clone(), serde_yaml::to_string(&config).unwrap()).unwrap();
+    std::fs::write(path.clone(), serde_yaml::to_string(&config).unwrap())
+       .expect("CONDUCTOR_CONFIG_FILENAME should be writable");
     path
 }
 

crates/snapmail-cli/src/cli.rs

@@ -81,7 +81,7 @@ impl SnapSubcommand {
       match self {
          Self::Setup(cmd)=> {
             msg!("Setup!");
-            cmd.run(sid).await;
+            cmd.run(sid).await?;
          },
          Self::Info => {
             msg!("{} Info:", sid_str);
@@ -105,7 +105,8 @@ impl SnapSubcommand {
          Self::ListSessions => {
             msg!("ListSessions: ");
             let root = CONFIG_PATH.as_path().to_path_buf();
-            let paths = std::fs::read_dir(root).unwrap();
+            let paths = std::fs::read_dir(root)
+               .expect("Missing config folder");
             for path in paths {
                msg!(" - {}", path.unwrap().path().display())
             }
@@ -184,7 +185,8 @@ impl SnapSubcommand {
             let handle_list = snapmail_get_all_handles(conductor.clone(), ())?;
             msg!(" {} mail(s) found:", all_mail_list.len());
             for item in all_mail_list.iter() {
-               let username = get_name(&handle_list, &item.author).unwrap();
+               let username = get_name(&handle_list, &item.author)
+                  .expect("DHT incoherent state as author's handle should publicly available");
                msg!("- {:?} | {} | {} | {}", item.state, username, item.mail.subject, item.address);
             }
             dump_state(conductor);

crates/snapmail-cli/src/subcommands/change.rs

@@ -36,7 +36,8 @@ impl ChangeCommand {
    fn update_uid(&self, sid: PathBuf, uid: &str) {
       let config_path = Path::new(&*CONFIG_PATH).join(sid.clone());
       let app_filepath = config_path.join(APP_CONFIG_FILENAME);
-      std::fs::write(app_filepath, uid.as_bytes()).unwrap();
+      std::fs::write(app_filepath, uid.as_bytes())
+         .expect("APP_CONFIG_FILENAME should be writable");
    }
 
    ///
@@ -64,6 +65,7 @@ impl ChangeCommand {
       }
       /// Write config
       msg!("New config:\n{}", file_str);
-      std::fs::write(config_filepath.clone(), file_str).unwrap();
+      std::fs::write(config_filepath.clone(), file_str)
+         .expect("CONDUCTOR_CONFIG_FILENAME should be writable");
    }
 }

crates/snapmail-cli/src/subcommands/listen.rs

@@ -17,10 +17,10 @@ use tokio::time::{Duration};
 pub async fn listen(conductor: ConductorHandle, loop_interval_sec: u64) -> anyhow::Result<()> {
 
    /// Add app interface so we can get signals
-   let mut interfaces = conductor.list_app_interfaces().await.unwrap();
+   let mut interfaces = conductor.list_app_interfaces().await?;
    if interfaces.is_empty() {
-      let _port = conductor.clone().add_app_interface(0).await.unwrap();
-      interfaces = conductor.list_app_interfaces().await.unwrap();
+      let _port = conductor.clone().add_app_interface(0).await?;
+      interfaces = conductor.list_app_interfaces().await?;
    }
    msg!("App Interfaces: {:?}", interfaces);
 
@@ -75,7 +75,12 @@ fn print_snapmail_signal(conductor: ConductorHandle, handle_list: &GetAllHandles
       }
       SignalProtocol::ReceivedAck(ack) => {
          let name = get_name(handle_list, &ack.from).unwrap_or("<unknown>".to_string());
-         let maybe_mail = snapmail_get_mail(conductor.clone(), ack.for_mail.clone()).unwrap();
+         let maybe_mail = snapmail_get_mail(conductor.clone(), ack.for_mail.clone());
+         if let Err(err) = maybe_mail {
+            msg!("snapmail_get_mail() failed during print_snapmail_signal(): {:?}", err);
+            return;
+         }
+         let maybe_mail = maybe_mail.unwrap();
          let subject = if let Some(mail) = maybe_mail.0 {
             match mail {
                Ok(inmail) => inmail.mail.subject,
@@ -94,7 +99,12 @@ fn print_snapmail_signal(conductor: ConductorHandle, handle_list: &GetAllHandles
 /// Get username from AgentPubKey
 /// Update Handle list if necessary
 pub fn try_get_name(conductor: ConductorHandle, candidate: &AgentPubKey) -> Result<String, ()> {
-   let handle_list = snapmail_get_all_handles(conductor.clone(), ()).unwrap().0;
+   let handle_list = snapmail_get_all_handles(conductor.clone(), ());
+   if let Err(err) = handle_list {
+      msg!("snapmail_get_all_handles() failed during try_get_name(): {:?}", err);
+      return Err(());
+   }
+   let handle_list = handle_list.unwrap().0;
    for pair in handle_list.iter() {
       if &pair.1 == candidate {
          return Ok(pair.0.clone());

crates/snapmail-cli/src/subcommands/open.rs

@@ -13,12 +13,16 @@ fn print_mail(handle_list: &GetAllHandlesOutput, mail: Mail, from: String, bcc:
    /// Get all CCs
    let mut cc_all = String::new();
    for cc in mail.cc.iter() {
-      cc_all = format!("{}, {}", cc_all, get_name(&handle_list, &cc).unwrap());
+      let name = get_name(&handle_list, &cc)
+         .expect("Should have found cc handle in DHT");
+      cc_all = format!("{}, {}", cc_all, name);
    }
    /// Get all BCCs
    let mut bcc_all = String::new();
    for bcc in bcc.iter() {
-      bcc_all = format!("{}, {}",bcc_all, get_name(&handle_list, &bcc).unwrap());
+      let name = get_name(&handle_list, &bcc)
+         .expect("Should have found bcc handle in DHT");
+      bcc_all = format!("{}, {}",bcc_all, name);
    }
    ///
    let date: DateTime<Local> = Local.timestamp(mail.date_sent as i64, 0);
@@ -44,7 +48,8 @@ pub async fn open(uid: String, hh: HeaderHash) -> anyhow::Result<()> {
       msg!(" - mail: {:?}", mail);
       match mail {
          Ok(inmail) => {
-            let from = get_name(&handle_list, &inmail.from).unwrap();
+            let from = get_name(&handle_list, &inmail.from)
+               .ok_or(anyhow::Error::msg("Handle not found"))?;
             print_mail(&handle_list, inmail.mail, from, vec![]);
             msg!("Acknowledging...");
             let maybe_hash = snapmail_acknowledge_mail(conductor, hh);

crates/snapmail-cli/src/subcommands/send.rs

@@ -45,7 +45,7 @@ impl SendCommand {
       let mut manifest_address_list: Vec<HeaderHash> = Vec::new();
       if let Some(attachment) = self.maybe_attachment {
          msg!("Reading attachment file: {:?}", attachment);
-         let hh = write_attachment(conductor.clone(), attachment).unwrap();
+         let hh = write_attachment(conductor.clone(), attachment)?;
          manifest_address_list.push(hh);
       }
       // Form MailInput
@@ -59,7 +59,7 @@ impl SendCommand {
       };
       let send_count = mail.to.len() + mail.cc.len() + mail.bcc.len();
       // Send
-      let output = snapmail_send_mail(conductor, mail).unwrap();
+      let output = snapmail_send_mail(conductor, mail)?;
       // Show results
       let pending_count = output.to_pendings.len() + output.cc_pendings.len() + output.bcc_pendings.len();
       msg!("Send done: {:?}", output.outmail);

crates/snapmail-cli/src/subcommands/setup.rs

@@ -23,9 +23,6 @@ pub struct SetupCommand {
    /// Network ID that this session will use
    uid: String,
 
-   // #[structopt(name = "mdns")]
-   // maybe_can_mdns: Option<bool>,
-
    // Set a root directory for the app's storage data to be placed into.
    // Defaults to the system's temp directory.
    // This directory must already exist.
@@ -35,7 +32,7 @@ pub struct SetupCommand {
 
 impl SetupCommand {
    ///
-   pub async fn run(&self, sid: PathBuf) {
+   pub async fn run(&self, sid: PathBuf) -> anyhow::Result<()> {
       let sid_str = sid.to_string_lossy().to_string();
       //let root = self.maybe_root.clone().unwrap_or(CONFIG_PATH.as_path().to_path_buf());
       let root = CONFIG_PATH.as_path().to_path_buf();
@@ -46,11 +43,12 @@ impl SetupCommand {
       ).expect("Generate config failed. Maybe Invalid params.");
 
 
-      let _dna_hash = install_app(sid.to_string_lossy().to_string(), self.uid.clone()).await.unwrap();
+      let _dna_hash = install_app(sid.to_string_lossy().to_string(), self.uid.clone()).await?;
       // msg!("    Using DNA: {}", dna_hash);
       let conductor = start_conductor(sid_str.clone()).await;
-      let hash = snapmail_set_handle(conductor, sid_str.clone()).unwrap();
+      let hash = snapmail_set_handle(conductor, sid_str.clone())?;
       msg!(" handle set: {} - {:?}", sid_str, hash);
+      Ok(())
    }
 }
 

crates/snapmail-tui/src/app.rs

@@ -142,12 +142,13 @@ impl App {
 
    ///
    pub fn show_selected_contact(&mut self) {
-      let selected = self.contacts_table.state.selected();
-      if selected.is_none() {
-         self.feedback(&format!("No selection"));
-         return;
-      }
-      let index = selected.unwrap();
+      let index = match self.contacts_table.state.selected() {
+         None => {
+            self.feedback(&format!("No selection"));
+            return;
+         }
+         Some(s) => s,
+      };
       let key = self.contacts_table.agent_index_map.get(&index).unwrap();
       let msg = format!("({}) Selected agent: {}", index, key);
       self.feedback(&msg);