add context to errors

Cargo.toml

@@ -9,6 +9,7 @@ categories = ["command-line-utilities"]
 homepage = "https://github.com/microsoft/avml"
 repository = "https://github.com/microsoft/avml"
 readme = "README.md"
+edition = "2018"
 
 [features]
 default = ["put", "blobstore"]
@@ -27,6 +28,7 @@ reqwest = { version = "0.9.19", default-features = false, features = ["rustls-tl
 azure = { version = "0.23.1", package = "azure_sdk_storage_blob", optional = true}
 azure_sdk_core = { version = "0.20.3", optional = true }
 azure_sdk_storage_core  = { version = "0.20.4", optional = true }
+anyhow = "1.0"
 
 [profile.release]
 opt-level="z"

src/bin/avml-convert.rs

@@ -3,21 +3,14 @@
 
 #[macro_use]
 extern crate clap;
-extern crate avml;
-extern crate byteorder;
-extern crate elf;
-extern crate snap;
 
+use anyhow::Result;
 use avml::ONE_MB;
 use clap::{App, Arg};
 use snap::Reader;
-use std::convert::TryFrom;
-use std::error::Error;
-use std::fs::metadata;
-use std::io::prelude::*;
-use std::io::SeekFrom;
+use std::{convert::TryFrom, fs::metadata, io::prelude::*, io::SeekFrom};
 
-fn convert(src: String, dst: String, compress: bool) -> Result<(), Box<dyn Error>> {
+fn convert(src: String, dst: String, compress: bool) -> Result<()> {
     let src_len = metadata(&src)?.len();
     let mut image = avml::image::Image::new(1, &src, &dst)?;
 
@@ -47,7 +40,7 @@ fn convert(src: String, dst: String, compress: bool) -> Result<(), Box<dyn Error
     Ok(())
 }
 
-fn convert_to_raw(src: String, dst: String) -> Result<(), Box<dyn Error>> {
+fn convert_to_raw(src: String, dst: String) -> Result<()> {
     let src_len = metadata(&src)?.len();
     let mut image = avml::image::Image::new(1, &src, &dst)?;
 
@@ -98,7 +91,7 @@ arg_enum! {
     }
 }
 
-fn main() -> Result<(), Box<dyn Error>> {
+fn main() -> Result<()> {
     let default_format = format!("{}", OutputFormat::lime);
     let args = App::new("avml-convert")
         .author(crate_authors!())

src/bin/avml.rs

@@ -3,29 +3,29 @@
 
 #[macro_use]
 extern crate clap;
-extern crate avml;
 
+use anyhow::{anyhow, bail, Context, Result};
 #[cfg(feature = "blobstore")]
 use avml::ONE_MB;
-
 use clap::{App, Arg};
-use std::error::Error;
 #[cfg(any(feature = "blobstore", feature = "put"))]
-use std::fs;
-use std::fs::metadata;
-use std::ops::Range;
-
-fn kcore(
-    ranges: &[std::ops::Range<u64>],
-    filename: &str,
-    version: u32,
-) -> Result<(), Box<dyn Error>> {
+use std::fs::remove_file;
+use std::{fs::metadata, ops::Range};
+
+fn kcore(ranges: &[std::ops::Range<u64>], filename: &str, version: u32) -> Result<()> {
     if metadata("/proc/kcore")?.len() < 0x2000 {
-        return Err(From::from("locked down kcore"));
+        bail!("locked down kcore");
     }
 
-    let mut image = avml::image::Image::new(version, "/proc/kcore", filename)?;
-    let mut file = elf::File::open_stream(&mut image.src).expect("unable to analyze /proc/kcore");
+    let mut image =
+        avml::image::Image::new(version, "/proc/kcore", filename).with_context(|| {
+            format!(
+                "unable to create image. source: /proc/kcore destination: {}",
+                filename
+            )
+        })?;
+    let mut file = elf::File::open_stream(&mut image.src)
+        .map_err(|e| anyhow!("unable to parse ELF structures from /proc/kcore: {:?}", e))?;
     file.phdrs.retain(|&x| x.progtype == elf::types::PT_LOAD);
     file.phdrs.sort_by(|a, b| a.vaddr.cmp(&b.vaddr));
     let start = file.phdrs[0].vaddr - ranges[0].start;
@@ -46,64 +46,68 @@ fn kcore(
     Ok(())
 }
 
-fn phys(
-    ranges: &[std::ops::Range<u64>],
-    filename: &str,
-    mem: &str,
-    version: u32,
-) -> Result<(), Box<dyn Error>> {
-    let mut image = avml::image::Image::new(version, mem, filename)?;
+fn phys(ranges: &[std::ops::Range<u64>], filename: &str, mem: &str, version: u32) -> Result<()> {
+    let mut image = avml::image::Image::new(version, mem, filename).with_context(|| {
+        format!(
+            "unable to create image. source:{} destination:{}",
+            mem, filename
+        )
+    })?;
     for range in ranges {
         let end = if mem == "/dev/crash" {
             (range.end >> 12) << 12
         } else {
             range.end
         };
 
-        image.write_block(
-            range.start,
-            Range {
-                start: range.start,
-                end,
-            },
-        )?;
+        image
+            .write_block(
+                range.start,
+                Range {
+                    start: range.start,
+                    end,
+                },
+            )
+            .with_context(|| format!("unable to write block: {}:{}", range.start, end))?;
     }
 
     Ok(())
 }
 
 macro_rules! try_method {
     ($func:expr) => {{
-        if $func.is_ok() {
-            return Ok(());
+        match $func {
+            Ok(_) => return Ok(()),
+            Err(err) => err,
         }
     }};
 }
 
-fn get_mem(src: Option<&str>, dst: &str, version: u32) -> Result<(), Box<dyn Error>> {
-    let ranges = avml::iomem::parse("/proc/iomem")?;
+fn get_mem(src: Option<&str>, dst: &str, version: u32) -> Result<()> {
+    let ranges = avml::iomem::parse("/proc/iomem").context("parsing /proc/iomem failed")?;
 
     if let Some(source) = src {
-        let result = match source {
-            "/proc/kcore" => kcore(&ranges, dst, version),
-            "/dev/crash" => phys(&ranges, dst, "/dev/crash", version),
-            "/dev/mem" => phys(&ranges, dst, "/dev/mem", version),
+        match source {
+            "/proc/kcore" => kcore(&ranges, dst, version)?,
+            "/dev/crash" => phys(&ranges, dst, "/dev/crash", version)?,
+            "/dev/mem" => phys(&ranges, dst, "/dev/mem", version)?,
             _ => unimplemented!(),
         };
-        if result.is_err() {
-            eprintln!("failed: {}", source);
-        }
-        return result;
     }
 
-    try_method!(phys(&ranges, dst, "/dev/crash", version));
-    try_method!(kcore(&ranges, dst, version));
-    try_method!(phys(&ranges, dst, "/dev/mem", version));
+    let crash_err = try_method!(phys(&ranges, dst, "/dev/crash", version));
+    let kcore_err = try_method!(kcore(&ranges, dst, version));
+    let devmem_err = try_method!(phys(&ranges, dst, "/dev/mem", version));
 
-    Err(From::from("unable to read physical memory"))
+    eprintln!("unable to read memory");
+    eprintln!("/dev/crash failed: {:?}", crash_err);
+    eprintln!("/proc/kcore failed: {:?}", kcore_err);
+    eprintln!("/dev/mem failed: {:?}", devmem_err);
+
+    bail!("unable to read physical memory")
 }
 
-fn main() -> Result<(), Box<dyn Error>> {
+fn main() -> Result<()> {
     let sources = vec!["/proc/kcore", "/dev/crash", "/dev/mem"];
     let args = App::new(crate_name!())
         .author(crate_authors!())
@@ -149,7 +153,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     let dst = value_t!(args.value_of("filename"), String)?;
     let version = if args.is_present("compress") { 2 } else { 1 };
 
-    get_mem(src, &dst, version)?;
+    get_mem(src, &dst, version).context("unable to collect memory")?;
 
     #[cfg(any(feature = "blobstore", feature = "put"))]
     let mut delete = false;
@@ -158,10 +162,8 @@ fn main() -> Result<(), Box<dyn Error>> {
     {
         let url = args.value_of("url");
         if let Some(url) = url {
-            avml::upload::put(&dst, url)?;
-            if args.is_present("delete") {
-                fs::remove_file(&dst)?;
-            }
+            avml::upload::put(&dst, url).context("unable to upload via PUT")?;
+            delete = true;
         }
     }
 
@@ -175,15 +177,16 @@ fn main() -> Result<(), Box<dyn Error>> {
         } * ONE_MB;
 
         if let Some(sas_url) = sas_url {
-            avml::blobstore::upload_sas(&dst, sas_url, sas_block_size)?;
+            avml::blobstore::upload_sas(&dst, sas_url, sas_block_size)
+                .context("upload via sas URL failed")?;
             delete = true;
         }
     }
 
     #[cfg(any(feature = "blobstore", feature = "put"))]
     {
         if delete && args.is_present("delete") {
-            fs::remove_file(&dst)?;
+            remove_file(&dst).context("unable to remove file after PUT")?;
         }
     }
 

src/blobstore.rs

@@ -2,19 +2,13 @@
 // Licensed under the MIT License.
 
 use crate::ONE_MB;
-
+use anyhow::{anyhow, bail, Context, Result};
 use azure::prelude::*;
-use azure_sdk_core::errors::AzureError;
-use azure_sdk_core::prelude::*;
+use azure_sdk_core::{errors::AzureError, prelude::*};
 use azure_sdk_storage_core::prelude::*;
-
 use byteorder::{LittleEndian, WriteBytesExt};
 use retry::{delay::jitter, delay::Exponential, retry, OperationResult};
-use std::cmp;
-use std::convert::TryFrom;
-use std::error::Error;
-use std::fs::File;
-use std::io::prelude::*;
+use std::{cmp, convert::TryFrom, fs::File, io::prelude::*};
 use tokio_core::reactor::Core;
 use url::Url;
 
@@ -23,20 +17,22 @@ const BACKOFF_COUNT: usize = 100;
 const MAX_BLOCK_SIZE: usize = ONE_MB * 100;
 
 /// Converts the block index into an block_id
-fn to_id(count: u64) -> Result<Vec<u8>, Box<dyn Error>> {
+fn to_id(count: u64) -> Result<Vec<u8>> {
     let mut bytes = vec![];
-    bytes.write_u64::<LittleEndian>(count)?;
+    bytes
+        .write_u64::<LittleEndian>(count)
+        .with_context(|| format!("unable to create block_id: {}", count))?;
     Ok(bytes)
 }
 
 /// Parse a SAS token into the relevant components
-fn parse(sas: &str) -> Result<(String, String, String), Box<dyn Error>> {
-    let parsed = Url::parse(sas)?;
+fn parse(sas: &str) -> Result<(String, String, String)> {
+    let parsed = Url::parse(sas).context("unable to parse url")?;
     let account = if let Some(host) = parsed.host_str() {
         let v: Vec<&str> = host.split_terminator('.').collect();
         v[0]
     } else {
-        return Err(From::from("invalid sas token (no account)"));
+        bail!("invalid sas token (no account)");
     };
 
     let path = parsed.path();
@@ -48,22 +44,29 @@ fn parse(sas: &str) -> Result<(String, String, String), Box<dyn Error>> {
 }
 
 /// Upload a file to Azure Blob Store using a fully qualified SAS token
-pub fn upload_sas(filename: &str, sas: &str, block_size: usize) -> Result<(), Box<dyn Error>> {
+pub fn upload_sas(filename: &str, sas: &str, block_size: usize) -> Result<()> {
     let block_size = cmp::min(block_size, MAX_BLOCK_SIZE);
-    let (account, container, path) = parse(sas)?;
-    let client = Client::azure_sas(&account, sas)?;
+    let (account, container, path) = parse(sas).context("unable to parse SAS url")?;
+    let client = Client::azure_sas(&account, sas)
+        .map_err(|e| anyhow!("creating blob client failed: {:?}", e))?;
 
-    let mut core = Core::new()?;
-    let mut file = File::open(filename)?;
-    let size = usize::try_from(file.metadata()?.len())?;
+    let mut core = Core::new().context("unable to create tokio context")?;
+    let mut file = File::open(filename).context("unable to open snapshot")?;
+    let size = usize::try_from(
+        file.metadata()
+            .context("unable to get file metadata")?
+            .len(),
+    )
+    .context("unable to convert file size")?;
     let mut sent = 0;
     let mut blocks = BlockList { blocks: Vec::new() };
     let mut data = vec![0; block_size];
     while sent < size {
         let send_size = cmp::min(block_size, size - sent);
         let block_id = to_id(sent as u64)?;
         data.resize(send_size, 0);
-        file.read_exact(&mut data)?;
+        file.read_exact(&mut data)
+            .context("unable to read image block")?;
 
         retry(
             Exponential::from_millis(BACKOFF)
@@ -88,7 +91,8 @@ pub fn upload_sas(filename: &str, sas: &str, block_size: usize) -> Result<(), Bo
                     },
                 }
             },
-        )?;
+        )
+        .map_err(|x| anyhow!("put_block_list failed: {:?}", x))?;
 
         blocks.blocks.push(BlobBlockType::Uncommitted(block_id));
         sent += send_size;
@@ -116,7 +120,8 @@ pub fn upload_sas(filename: &str, sas: &str, block_size: usize) -> Result<(), Bo
                 },
             }
         },
-    )?;
+    )
+    .map_err(|x| anyhow!("put_block_list failed: {:?}", x))?;
 
     Ok(())
 }