2 files changed, 26 insertions, 59 deletions
diff --git a/src/launcher.rs b/src/launcher.rs
index 98a8020..e207281 100644
--- a/src/launcher.rs
+++ b/src/launcher.rs
@@ -195,41 +195,6 @@ impl LibraryRepository {
         p.push(Self::get_artifact_filename(name, classifier)?);
         Some(p)
     }
-
-    async fn should_redownload(&self, lib: &Library, classifier: Option<&str>) -> Result<bool, LibraryError> {
-        let path = Self::get_artifact_path(lib.name.as_str(), classifier)
-            .map_or_else(|| Err(LibraryError::InvalidName(lib.name.clone())), |p| Ok(p))?;
-
-        let mut f = match File::open(path).await {
-            Ok(f) => f,
-            Err(e) => return match e.kind() {
-                ErrorKind::NotFound => Ok(true),
-                e => Err(LibraryError::IOError(e))
-            }
-        };
-
-        let mut data = [0u8; 4096];
-        let mut sha1 = Sha1::new();
-
-        loop {
-            let n = match f.read(&mut data).await {
-                Ok(n) => n,
-                Err(e) => return match e.kind() {
-                    ErrorKind::Interrupted => continue,
-                    kind => Err(LibraryError::IOError(kind))
-                }
-            };
-
-            if n == 0 {
-                break; // we reached the end of the file
-            }
-
-            sha1.update(&data[..n]);
-        }
-
-
-        todo!()
-    }
 }
 
 impl SystemInfo {
diff --git a/src/launcher/download.rs b/src/launcher/download.rs
index ca1c57d..28c3b86 100644
--- a/src/launcher/download.rs
+++ b/src/launcher/download.rs
@@ -101,34 +101,29 @@ impl<T: Download> MultiDownloader<T> {
     pub async fn perform(&mut self) -> impl Stream<Item = Result<(), PhaseDownloadError<T>>> {
         stream::iter(self.jobs.iter_mut()).map(|job| {
             let client = &self.client;
+            
+            macro_rules! map_err {
+                ($result:expr, $phase:expr, $job:expr) => {
+                    match $result {
+                        Ok(v) => v,
+                        Err(e) => return Err(PhaseDownloadError::new($phase, e.into(), $job))
+                    }
+                }
+            }
 
             async move {
-                let rq = match job.prepare(client.request(Method::GET, job.get_url()).header(reqwest::header::USER_AGENT, USER_AGENT)).await {
-                    Ok(opt) => match opt {
-                        Some(rq) => rq,
-                        None => return Ok(())
-                    },
-                    Err(e) => return Err(PhaseDownloadError::new(Phase::Prepare, e, job))
-                };
-
-                let mut data = match rq.send().await {
-                    Ok(data) => match data.error_for_status() {
-                        Ok(data) => data.bytes_stream(),
-                        Err(e) => return Err(PhaseDownloadError::new(Phase::Send, e.into(), job))
-                    },
-                    Err(e) => return Err(PhaseDownloadError::new(Phase::Send, e.into(), job))
+                let Some(rq) = map_err!(
+                    job.prepare(client.request(Method::GET, job.get_url())
+                        .header(reqwest::header::USER_AGENT, USER_AGENT)).await, Phase::Prepare, job) else {
+                    return Ok(())
                 };
+                
+                let mut data = map_err!(map_err!(rq.send().await, Phase::Send, job).error_for_status(), Phase::Send, job).bytes_stream();
 
                 while let Some(bytes) = data.next().await {
-                    let bytes = match bytes {
-                        Ok(bytes) => bytes,
-                        Err(e) => return Err(PhaseDownloadError::new(Phase::Receive, e.into(), job))
-                    };
-
-                    match job.handle_chunk(bytes.as_ref()).await {
-                        Ok(_) => (),
-                        Err(e) => return Err(PhaseDownloadError::new(Phase::HandleChunk, e.into(), job))
-                    }
+                    let bytes = map_err!(bytes, Phase::Receive, job);
+
+                    map_err!(job.handle_chunk(bytes.as_ref()).await, Phase::HandleChunk, job);
                 }
 
                 job.finish().await.map_err(|e| PhaseDownloadError::new(Phase::Finish, e.into(), job))?;
@@ -237,7 +232,14 @@ impl Download for VerifiedDownload {
 
         let mut buf = [0u8; 4096];
         loop {
-            let n = file.read(&mut buf).await?;
+            let n = match file.read(&mut buf).await {
+                Ok(n) => n,
+                Err(e) => match e.kind() {
+                    ErrorKind::Interrupted => continue,
+                    _ => return Err(e.into())
+                }
+            };
+
             if n == 0 { break; }
 
             tally += n;