Auto merge of #620 - Mark-Simulacrum:drop-humanize-dep, r=Mark-Simulacrum

bors · bors · commit 59689eb1ed51 · 2022-03-17T23:38:19.000Z
Humanize to hours at most

Days are typically fairly non-granular, and most of our runtimes are roughly in
the 48 hour-ish window. Hours should give a much better picture of when to
expect results.

This also drops a dependency in favor of manually humanizing the time.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -16,7 +16,6 @@ opt-level = 0
 base64 = "0.13.0"
 bytes = "0.4.9"
 chrono = { version = "0.4", features = ["serde"] }
-chrono-humanize = "0.1.1"
 crates-index = "0.16.2"
 crossbeam-utils = "0.5"
 crossbeam-channel = "0.5"
diff --git a/src/crates/lists.rs b/src/crates/lists.rs
@@ -88,7 +88,7 @@ pub(crate) fn get_crates(
             all_crates.append(&mut GitHubList::get(db)?);
             all_crates.append(&mut LocalList::get(db)?);
 
-            for krate in all_crates.drain(..) {
+            for krate in all_crates {
                 let add = match krate {
                     Crate::Registry(RegistryCrate { ref name, .. }) => demo_registry.remove(name),
                     Crate::GitHub(ref repo) => demo_github.remove(&repo.slug()),
diff --git a/src/runner/graph.rs b/src/runner/graph.rs
@@ -155,11 +155,11 @@ impl TasksGraph {
 
         // Try to check for the dependencies of this node
         // The list is collected to make the borrowchecker happy
-        let mut neighbors = self.graph.neighbors(node).collect::<Vec<_>>();
+        let neighbors = self.graph.neighbors(node).collect::<Vec<_>>();
         log::trace!("{} | {:?}: neighbors: {:?}", worker, node, neighbors);
 
         let mut blocked = false;
-        for neighbor in neighbors.drain(..) {
+        for neighbor in neighbors {
             match self.walk_graph(neighbor, ex, db, worker) {
                 WalkResult::Task(id, task) => return WalkResult::Task(id, task),
                 WalkResult::Finished => return WalkResult::Finished,
@@ -219,12 +219,12 @@ impl TasksGraph {
         result: &TestResult,
         worker: &str,
     ) -> Fallible<()> {
-        let mut children = self
+        let children = self
             .graph
             .neighbors_directed(node, Direction::Incoming)
             .collect::<Vec<_>>();
         let mut last_err = None;
-        for child in children.drain(..) {
+        for child in children {
             // Don't recursively mark a child as failed if this is not the only parent of the child
             let parents = self
                 .graph
diff --git a/src/runner/mod.rs b/src/runner/mod.rs
@@ -157,7 +157,7 @@ pub fn run_ex<DB: WriteResults + Sync>(
                     Ok(())
                 })?;
 
-        let clean_exit = join_threads(threads.drain(..));
+        let clean_exit = join_threads(threads.into_iter());
         disk_watcher.stop();
         let disk_watcher_clean_exit = join_threads(std::iter::once(disk_watcher_thread));
 
diff --git a/src/server/routes/ui/experiments.rs b/src/server/routes/ui/experiments.rs
@@ -4,7 +4,6 @@ use crate::report::ResultName;
 use crate::server::routes::ui::{render_template, LayoutContext};
 use crate::server::{Data, HttpError};
 use chrono::{Duration, SecondsFormat, Utc};
-use chrono_humanize::{Accuracy, HumanTime, Tense};
 use http::Response;
 use hyper::Body;
 use std::collections::HashMap;
@@ -134,6 +133,17 @@ struct ExperimentContext {
     layout: LayoutContext,
 }
 
+fn humanize(duration: Duration) -> String {
+    let duration = duration.to_std().expect("non-negative duration");
+    if duration.as_secs() < 60 {
+        format!("{:?}", duration)
+    } else if duration.as_secs() < 60 * 60 {
+        format!("{} minutes", duration.as_secs() / 60)
+    } else {
+        format!("{:.1} hours", duration.as_secs_f64() / 60.0 / 60.0)
+    }
+}
+
 pub fn endpoint_experiment(name: String, data: Arc<Data>) -> Fallible<Response<Body>> {
     if let Some(ex) = Experiment::get(&data.db, &name)? {
         let (completed_jobs, total_jobs) = ex.raw_progress(&data.db)?;
@@ -146,43 +156,31 @@ pub fn endpoint_experiment(name: String, data: Arc<Data>) -> Fallible<Response<B
         let mut result_counts = result_counts.into_iter().collect::<Vec<_>>();
         result_counts.sort_by(|v1, v2| (v1.0).cmp(&v2.0));
 
-        let (duration, estimated_end, average_job_duration) = if completed_jobs > 0
-            && total_jobs > 0
-        {
-            if let Some(started_at) = ex.started_at {
-                let res = if let Some(completed_at) = ex.completed_at {
-                    let total = completed_at.signed_duration_since(started_at);
-                    (Some(total), None, total / completed_jobs as i32)
-                } else {
-                    let total = Utc::now().signed_duration_since(started_at);
-                    let job_duration = total / completed_jobs as i32;
-                    (
-                        None,
-                        Some(job_duration * (total_jobs as i32 - completed_jobs as i32)),
-                        job_duration,
-                    )
-                };
-
-                let job_duration = if res.2 < Duration::seconds(3) {
-                    let job_duration = res.2.to_std().expect("negative job time");
-                    format!("{:.2?}", job_duration)
+        let (duration, estimated_end, average_job_duration) =
+            if completed_jobs > 0 && total_jobs > 0 {
+                if let Some(started_at) = ex.started_at {
+                    let res = if let Some(completed_at) = ex.completed_at {
+                        let total = completed_at.signed_duration_since(started_at);
+                        (Some(total), None, total / completed_jobs as i32)
+                    } else {
+                        let total = Utc::now().signed_duration_since(started_at);
+                        let job_duration = total / completed_jobs as i32;
+                        (
+                            None,
+                            Some(job_duration * (total_jobs as i32 - completed_jobs as i32)),
+                            job_duration,
+                        )
+                    };
+
+                    let job_duration = humanize(res.2);
+
+                    (res.0.map(humanize), res.1.map(humanize), Some(job_duration))
                 } else {
-                    HumanTime::from(res.2).to_text_en(Accuracy::Precise, Tense::Present)
-                };
-
-                (
-                    res.0
-                        .map(|r| HumanTime::from(r).to_text_en(Accuracy::Rough, Tense::Present)),
-                    res.1
-                        .map(|r| HumanTime::from(r).to_text_en(Accuracy::Rough, Tense::Present)),
-                    Some(job_duration),
-                )
+                    (None, None, None)
+                }
             } else {
                 (None, None, None)
-            }
-        } else {
-            (None, None, None)
-        };
+            };
 
         let experiment = ExperimentExt {
             common: ExperimentData::new(&data, &ex)?,
