Refactor to avoid duplication of the log entry creation

Author: Mark-Simulacrum

src/report/archives.rs

@@ -2,7 +2,7 @@ use crate::config::Config;
 use crate::crates::Crate;
 use crate::experiments::Experiment;
 use crate::prelude::*;
-use crate::report::{compare, ReportWriter};
+use crate::report::{compare, Comparison, ReportWriter};
 use crate::results::{EncodedLog, EncodingType, ReadResults};
 use flate2::{write::GzEncoder, Compression};
 use indexmap::IndexMap;
@@ -14,6 +14,84 @@ pub struct Archive {
     path: String,
 }
 
+struct LogEntry {
+    path: String,
+    comparison: Comparison,
+    log_bytes: Vec<u8>,
+}
+
+impl LogEntry {
+    fn header(&self) -> TarHeader {
+        let mut header = TarHeader::new_gnu();
+        header.set_size(self.log_bytes.len() as u64);
+        header.set_mode(0o644);
+        header.set_cksum();
+        header
+    }
+}
+
+fn iterate<'a, DB: ReadResults + 'a>(
+    db: &'a DB,
+    ex: &'a Experiment,
+    crates: &'a [Crate],
+    config: &'a Config,
+) -> impl Iterator<Item = Fallible<LogEntry>> + 'a {
+    let mut iter = crates
+        .iter()
+        .filter(move |krate| !config.should_skip(krate))
+        .map(move |krate| -> Fallible<Vec<LogEntry>> {
+            let res1 = db.load_test_result(ex, &ex.toolchains[0], krate)?;
+            let res2 = db.load_test_result(ex, &ex.toolchains[1], krate)?;
+            let comparison = compare(config, krate, res1.as_ref(), res2.as_ref());
+
+            ex.toolchains
+                .iter()
+                .filter_map(move |tc| {
+                    let log = db
+                        .load_log(ex, tc, krate)
+                        .and_then(|c| c.ok_or_else(|| err_msg("missing logs")))
+                        .with_context(|_| format!("failed to read log of {} on {}", krate, tc));
+
+                    let log_bytes: EncodedLog = match log {
+                        Ok(l) => l,
+                        Err(e) => {
+                            crate::utils::report_failure(&e);
+                            return None;
+                        }
+                    };
+
+                    let log_bytes = match log_bytes.to_plain() {
+                        Ok(it) => it,
+                        Err(err) => return Some(Err(err)),
+                    };
+
+                    let path = format!(
+                        "{}/{}/{}.txt",
+                        comparison,
+                        krate.id(),
+                        tc.to_path_component(),
+                    );
+                    Some(Ok(LogEntry {
+                        path,
+                        comparison,
+                        log_bytes,
+                    }))
+                })
+                .collect()
+        });
+
+    let mut in_progress = vec![].into_iter();
+    std::iter::from_fn(move || loop {
+        if let Some(next) = in_progress.next() {
+            return Some(Ok(next));
+        }
+        match iter.next()? {
+            Ok(list) => in_progress = list.into_iter(),
+            Err(err) => return Some(Err(err)),
+        }
+    })
+}
+
 fn write_all_archive<DB: ReadResults, W: ReportWriter>(
     db: &DB,
     ex: &Experiment,
@@ -23,46 +101,10 @@ fn write_all_archive<DB: ReadResults, W: ReportWriter>(
 ) -> Fallible<Archive> {
     for i in 1..=RETRIES {
         let mut all = TarBuilder::new(GzEncoder::new(Vec::new(), Compression::default()));
-        for krate in crates {
-            if config.should_skip(krate) {
-                continue;
-            }
-
-            let res1 = db.load_test_result(ex, &ex.toolchains[0], krate)?;
-            let res2 = db.load_test_result(ex, &ex.toolchains[1], krate)?;
-            let comparison = compare(config, krate, res1.as_ref(), res2.as_ref());
-
-            for tc in &ex.toolchains {
-                let log = db
-                    .load_log(ex, tc, krate)
-                    .and_then(|c| c.ok_or_else(|| err_msg("missing logs")))
-                    .with_context(|_| format!("failed to read log of {} on {}", krate, tc));
-
-                let log_bytes: EncodedLog = match log {
-                    Ok(l) => l,
-                    Err(e) => {
-                        crate::utils::report_failure(&e);
-                        continue;
-                    }
-                };
-
-                let log_bytes = log_bytes.to_plain()?;
-                let log_bytes = log_bytes.as_slice();
-
-                let path = format!(
-                    "{}/{}/{}.txt",
-                    comparison,
-                    krate.id(),
-                    tc.to_path_component(),
-                );
-
-                let mut header = TarHeader::new_gnu();
-                header.set_size(log_bytes.len() as u64);
-                header.set_mode(0o644);
-                header.set_cksum();
-
-                all.append_data(&mut header, &path, log_bytes)?;
-            }
+        for entry in iterate(db, ex, crates, config) {
+            let entry = entry?;
+            let mut header = entry.header();
+            all.append_data(&mut header, &entry.path, &entry.log_bytes[..])?;
         }
 
         let data = all.into_inner()?.finish()?;
@@ -109,51 +151,13 @@ pub fn write_logs_archives<DB: ReadResults, W: ReportWriter>(
 
     archives.push(write_all_archive(db, ex, crates, dest, config)?);
 
-    for krate in crates {
-        if config.should_skip(krate) {
-            continue;
-        }
-
-        let res1 = db.load_test_result(ex, &ex.toolchains[0], krate)?;
-        let res2 = db.load_test_result(ex, &ex.toolchains[1], krate)?;
-        let comparison = compare(config, krate, res1.as_ref(), res2.as_ref());
-
-        for tc in &ex.toolchains {
-            let log = db
-                .load_log(ex, tc, krate)
-                .and_then(|c| c.ok_or_else(|| err_msg("missing logs")))
-                .with_context(|_| format!("failed to read log of {} on {}", krate, tc));
+    for entry in iterate(db, ex, crates, config) {
+        let entry = entry?;
 
-            let log_bytes: EncodedLog = match log {
-                Ok(l) => l,
-                Err(e) => {
-                    crate::utils::report_failure(&e);
-                    continue;
-                }
-            };
-
-            let log_bytes = log_bytes.to_plain()?;
-            let log_bytes = log_bytes.as_slice();
-
-            let path = format!(
-                "{}/{}/{}.txt",
-                comparison,
-                krate.id(),
-                tc.to_path_component(),
-            );
-
-            let mut header = TarHeader::new_gnu();
-            header.set_size(log_bytes.len() as u64);
-            header.set_mode(0o644);
-            header.set_cksum();
-
-            by_comparison
-                .entry(comparison)
-                .or_insert_with(|| {
-                    TarBuilder::new(GzEncoder::new(Vec::new(), Compression::default()))
-                })
-                .append_data(&mut header, &path, log_bytes)?;
-        }
+        by_comparison
+            .entry(entry.comparison)
+            .or_insert_with(|| TarBuilder::new(GzEncoder::new(Vec::new(), Compression::default())))
+            .append_data(&mut entry.header(), &entry.path, &entry.log_bytes[..])?;
     }
 
     for (comparison, archive) in by_comparison.drain(..) {