use a macro for map_err

1 files changed, 26 insertions, 24 deletions

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;