Merge pull request #95 from james-parky/dev-anyhow-rem

Remove `anyhow` Dependency

Author: dongsupark

Cargo.lock

@@ -6,7 +6,6 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-anyhow = "1.0.75"
 argh = "0.1"
 env_logger = "0.10"
 globset = "0.4"

Cargo.toml

@@ -1,12 +1,11 @@
 use std::error::Error;
 use std::borrow::Cow;
 
-use anyhow::{Context, Result};
 use hard_xml::XmlRead;
 use url::Url;
 use omaha::Sha256Digest;
 
-fn get_pkgs_to_download(resp: &omaha::Response) -> Result<Vec<(Url, Sha256Digest)>> {
+fn get_pkgs_to_download(resp: &omaha::Response) -> Result<Vec<(Url, Sha256Digest)>, ()> {
     let mut to_download: Vec<(Url, Sha256Digest)> = Vec::new();
 
     for app in &resp.apps {
@@ -59,19 +58,18 @@ fn main() -> Result<(), Box<dyn Error>> {
         track: Cow::Borrowed(TRACK_DEFAULT),
     };
 
-    let response_text = ue_rs::request::perform(&client, parameters).context(format!(
-        "perform({APP_VERSION_DEFAULT}, {MACHINE_ID_DEFAULT}, {TRACK_DEFAULT}) failed"
-    ))?;
+    let response_text = ue_rs::request::perform(&client, parameters)?;
 
     println!("response:\n\t{:#?}", response_text);
     println!();
 
     ////
     // parse response
     ////
-    let resp = omaha::Response::from_str(&response_text).context("failed to parse response")?;
+    let resp = omaha::Response::from_str(&response_text)?;
 
-    let pkgs_to_dl = get_pkgs_to_download(&resp).context("failed to get packages to download")?;
+    // TODO: fine for an example but shouldnt recommend
+    let pkgs_to_dl = get_pkgs_to_download(&resp).unwrap();
 
     ////
     // download
@@ -81,7 +79,7 @@ fn main() -> Result<(), Box<dyn Error>> {
 
         let tempdir = tempfile::tempdir()?;
         let path = tempdir.path().join("tmpfile");
-        let res = ue_rs::download_and_hash(&client, url.clone(), &path, Some(expected_sha256.clone()), None).context(format!("download_and_hash({url:?}) failed"))?;
+        let res = ue_rs::download_and_hash(&client, url.clone(), &path, Some(expected_sha256.clone()), None)?;
         tempdir.close()?;
 
         println!("\texpected sha256:   {:?}", expected_sha256);

examples/full_test.rs

@@ -1,8 +1,6 @@
 use std::error::Error;
 use std::borrow::Cow;
 
-use anyhow::Context;
-
 use ue_rs::request;
 
 fn main() -> Result<(), Box<dyn Error>> {
@@ -19,9 +17,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         track: Cow::Borrowed(TRACK_DEFAULT),
     };
 
-    let response = request::perform(&client, parameters).context(format!(
-        "perform({APP_VERSION_DEFAULT}, {MACHINE_ID_DEFAULT}, {TRACK_DEFAULT}) failed"
-    ))?;
+    let response = request::perform(&client, parameters)?;
 
     println!("response:\n\t{:#?}", response);
 

examples/request.rs

@@ -1,6 +1,5 @@
 use std::error::Error;
 
-use anyhow::Context;
 use hard_xml::XmlRead;
 use omaha;
 
@@ -30,7 +29,8 @@ fn main() -> Result<(), Box<dyn Error>> {
     println!("{}", RESPONSE_XML);
     println!();
 
-    let resp = omaha::Response::from_str(RESPONSE_XML).context("failed to create response")?;
+    // TODO: fine for a small example but shouldnt be encouraged
+    let resp = omaha::Response::from_str(RESPONSE_XML).unwrap();
 
     println!("{:#?}", resp);
     println!();
@@ -70,7 +70,8 @@ fn main() -> Result<(), Box<dyn Error>> {
             for url in &app.update_check.urls {
                 println!(
                     "        {}",
-                    url.join(&pkg.name).context(format!("failed to join URL with {:?}", pkg.name))?
+                    // TODO: fine for a small example but shouldnt be encouraged
+                    url.join(&pkg.name).unwrap()
                 );
             }
 

examples/response.rs

@@ -6,7 +6,6 @@ use std::path::Path;
 #[macro_use]
 extern crate log;
 
-use anyhow::Result;
 use argh::FromArgs;
 use globset::{Glob, GlobSet, GlobSetBuilder};
 

src/bin/download_sysext.rs

@@ -9,15 +9,16 @@ use std::path::Path;
 use std::str::FromStr;
 use std::time::Duration;
 
-use anyhow::{Context, Result, anyhow, bail};
 use globset::GlobSet;
 use hard_xml::XmlRead;
 use log::{debug, info, warn};
-use reqwest::{StatusCode, blocking::Client, redirect::Policy};
+use reqwest::{blocking::Client, redirect::Policy};
 use url::Url;
 
 use crate::{Package, PackageStatus};
 use omaha::{Sha1Digest, Sha256Digest};
+use crate::error::Error;
+use crate::Result;
 
 const DOWNLOAD_TIMEOUT: u64 = 3600;
 const HTTP_CONN_TIMEOUT: u64 = 20;
@@ -33,9 +34,9 @@ pub struct DownloadResult {
 }
 
 pub fn hash_on_disk<T: omaha::Hasher>(path: &Path, maxlen: Option<usize>) -> Result<T::Output> {
-    let file = File::open(path).context(format!("File::open({:?})", path))?;
+    let file = File::open(path).map_err(Error::OpenFile)?;
 
-    let filelen = file.metadata().context(format!("failed to get metadata of {:?}", path))?.len() as usize;
+    let filelen = file.metadata().map_err(Error::GetFileMetadata)?.len() as usize;
 
     let mut maxlen_to_read: usize = match maxlen {
         Some(len) => {
@@ -61,7 +62,7 @@ pub fn hash_on_disk<T: omaha::Hasher>(path: &Path, maxlen: Option<usize>) -> Res
             databuf.truncate(maxlen_to_read);
         }
 
-        freader.read_exact(&mut databuf).context(format!("failed to read_exact(chunklen {:?})", databuf.len()))?;
+        freader.read_exact(&mut databuf).map_err(Error::ReadFromFile)?;
 
         maxlen_to_read -= databuf.len();
 
@@ -78,33 +79,23 @@ where
 {
     let client_url = url.clone();
 
-    #[rustfmt::skip]
-    let mut res = client.get(url.clone())
-        .send()
-        .context(format!("client get & send{:?} failed ", client_url.as_str()))?;
+    let mut res = client.get(url.clone()).send().map_err(|err| Error::SendGetRequest(url.into(), err))?;
 
     // Redirect was already handled at this point, so there is no need to touch
     // response or url again. Simply print info and continue.
     if <U as Into<Url>>::into(client_url) != *res.url() {
         info!("redirected to URL {:?}", res.url());
     }
 
-    // Return immediately on download failure on the client side.
-    let status = res.status();
-
-    if !status.is_success() {
-        match status {
-            StatusCode::FORBIDDEN | StatusCode::NOT_FOUND => {
-                bail!("cannnot fetch remotely with status code {:?}", status);
-            }
-            _ => bail!("general failure with status code {:?}", status),
-        }
+    match res.status() {
+        status if !status.is_success() => return Err(Error::GetRequestFailed(status)),
+        _ => {}
     }
 
     println!("writing to {}", path.display());
 
-    let mut file = File::create(path).context(format!("failed to create path ({:?})", path.display()))?;
-    res.copy_to(&mut file)?;
+    let mut file = File::create(path).map_err(Error::CreateFile)?;
+    res.copy_to(&mut file).map_err(Error::CopyRequestBodyToFile)?;
 
     let calculated_sha256 = hash_on_disk::<omaha::Sha256>(path, None)?;
     let calculated_sha1 = hash_on_disk::<omaha::Sha1>(path, None)?;
@@ -116,11 +107,14 @@ where
     debug!("    calculated sha1: {calculated_sha1:?}");
     debug!("    sha1 match?      {}", expected_sha1 == Some(calculated_sha1));
 
-    if expected_sha256.is_some() && expected_sha256 != Some(calculated_sha256) {
-        bail!("checksum mismatch for sha256");
+    match expected_sha256 {
+        Some(exp) if exp != calculated_sha256 => return Err(Error::Sha256ChecksumMismatch(exp, calculated_sha256)),
+        _ => {}
     }
-    if expected_sha1.is_some() && expected_sha1 != Some(calculated_sha1) {
-        bail!("checksum mismatch for sha1");
+
+    match expected_sha1 {
+        Some(exp) if exp != calculated_sha1 => return Err(Error::Sha1ChecksumMismatch(exp, calculated_sha1)),
+        _ => {}
     }
 
     Ok(DownloadResult {
@@ -189,13 +183,13 @@ where
     U: reqwest::IntoUrl + From<U> + std::clone::Clone + std::fmt::Debug,
     Url: From<U>,
 {
-    let r = download_and_hash(client, input_url.clone(), path, None, None).context(format!("unable to download data(url {input_url:?})"))?;
+    let r = download_and_hash(client, input_url.clone(), path, None, None)?;
 
     Ok(Package {
         name: Cow::Borrowed(path.file_name().unwrap_or(OsStr::new("fakepackage")).to_str().unwrap_or("fakepackage")),
         hash_sha256: Some(r.hash_sha256),
         hash_sha1: Some(r.hash_sha1),
-        size: r.data.metadata().context(format!("failed to get metadata, path ({:?})", path.display()))?.len() as usize,
+        size: r.data.metadata().map_err(Error::GetFileMetadata)?.len() as usize,
         url: input_url.into(),
         status: PackageStatus::Unverified,
     })
@@ -204,19 +198,19 @@ where
 fn do_download_verify(pkg: &mut Package<'_>, output_filename: Option<String>, output_dir: &Path, unverified_dir: &Path, pubkey_file: &str, client: &Client) -> Result<()> {
     pkg.check_download(unverified_dir)?;
 
-    pkg.download(unverified_dir, client).context(format!("unable to download \"{:?}\"", pkg.name))?;
+    pkg.download(unverified_dir, client)?;
 
     // Unverified payload is stored in e.g. "output_dir/.unverified/oem.gz".
     // Verified payload is stored in e.g. "output_dir/oem.raw".
     let pkg_unverified = unverified_dir.join(&*pkg.name);
     let mut pkg_verified = output_dir.join(output_filename.as_ref().map(OsStr::new).unwrap_or(pkg_unverified.with_extension("raw").file_name().unwrap_or_default()));
     pkg_verified.set_extension("raw");
 
-    let datablobspath = pkg.verify_signature_on_disk(&pkg_unverified, pubkey_file).context(format!("unable to verify signature \"{}\"", pkg.name))?;
+    let datablobspath = pkg.verify_signature_on_disk(&pkg_unverified, pubkey_file)?;
 
     // write extracted data into the final data.
     debug!("data blobs written into file {pkg_verified:?}");
-    fs::rename(datablobspath, pkg_verified)?;
+    fs::rename(datablobspath, pkg_verified).map_err(Error::RenameFile)?;
 
     Ok(())
 }
@@ -264,27 +258,28 @@ impl DownloadVerify {
 
         let unverified_dir = output_dir.join(UNVERFIED_SUFFIX);
         let temp_dir = output_dir.join(TMP_SUFFIX);
-        fs::create_dir_all(&unverified_dir)?;
-        fs::create_dir_all(&temp_dir)?;
+        fs::create_dir_all(&unverified_dir).map_err(Error::CreateDirectory)?;
+        fs::create_dir_all(&temp_dir).map_err(Error::CreateDirectory)?;
 
         // The default policy of reqwest Client supports max 10 attempts on HTTP redirect.
         let client = Client::builder()
             .tcp_keepalive(Duration::from_secs(HTTP_CONN_TIMEOUT))
             .connect_timeout(Duration::from_secs(HTTP_CONN_TIMEOUT))
             .timeout(Duration::from_secs(DOWNLOAD_TIMEOUT))
             .redirect(Policy::default())
-            .build()?;
+            .build()
+            .map_err(Error::BuildClient)?;
 
         if self.payload_url.is_some() {
             let url = self.payload_url.clone().unwrap();
-            let u = Url::parse(&url)?;
-            let fname = u.path_segments().ok_or(anyhow!("failed to get path segments, url ({:?})", u))?.next_back().ok_or(anyhow!("failed to get path segments, url ({:?})", u))?;
+            let u = Url::parse(&url).map_err(Error::ParseUrl)?;
+            let fname = u.path_segments().ok_or(Error::InvalidBaseUrl(u.clone()))?.next_back().ok_or(Error::EmptyUrlIterator)?;
             let mut pkg_fake: Package;
 
             let temp_payload_path = unverified_dir.join(fname);
             pkg_fake = fetch_url_to_file(
                 &temp_payload_path,
-                Url::from_str(url.as_str()).context(anyhow!("failed to convert into url ({:?})", self.payload_url))?,
+                Url::from_str(url.as_str()).map_err(Error::ParseUrl)?,
                 &client,
             )?;
             do_download_verify(
@@ -303,7 +298,7 @@ impl DownloadVerify {
         ////
         // parse response
         ////
-        let resp = omaha::Response::from_str(&self.input_xml)?;
+        let resp = omaha::Response::from_str(&self.input_xml).map_err(Error::InvalidHashDigestString)?;
 
         let mut pkgs_to_dl = get_pkgs_to_download(&resp, &self.glob_set)?;
 
@@ -329,7 +324,7 @@ impl DownloadVerify {
         }
 
         // clean up data
-        fs::remove_dir_all(temp_dir)?;
+        fs::remove_dir_all(temp_dir).map_err(Error::RemoveDirectory)?;
 
         Ok(())
     }