move back Bound to the site

s7tya · s7tya · commit ffbd562cad8a · 2024-08-05T21:29:05.000+09:00
diff --git a/collector/src/lib.rs b/collector/src/lib.rs
@@ -1,6 +1,8 @@
+use chrono::NaiveDate;
 pub use database::{Commit, PatchName, QueryLabel};
 use serde::Deserialize;
 use std::cmp::PartialOrd;
+use std::fmt;
 use std::process::{self, Command};
 
 pub mod api;
@@ -21,6 +23,94 @@ use std::time::{Duration, Instant};
 #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Deserialize)]
 pub struct DeltaTime(#[serde(with = "round_float")] pub f64);
 
+/// The bound for finding an artifact
+///
+/// This can either be the upper or lower bound.
+/// In the case of commits or tags this is an exact bound, but for dates
+/// it's a best effort (i.e., if the bound is a date but there are no artifacts
+/// for that date, we'll find the artifact that most closely matches).
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub enum Bound {
+    /// An unverified git commit (in sha form) or a tag of a commit (e.g., "1.53.0")
+    Commit(String),
+    /// A date in time
+    Date(NaiveDate),
+    /// No bound
+    #[default]
+    None,
+}
+
+impl Bound {
+    /// Tests whether `self` matches commit when searching from the left
+    pub fn left_match(&self, commit: &Commit) -> bool {
+        match self {
+            Bound::Commit(sha) => commit.sha == **sha,
+            Bound::Date(date) => commit.is_master() && commit.date.0.naive_utc().date() >= *date,
+            Bound::None => {
+                let last_month = chrono::Utc::now().date_naive() - chrono::Duration::days(30);
+                commit.is_master() && last_month <= commit.date.0.naive_utc().date()
+            }
+        }
+    }
+
+    /// Tests whether `self` matches commit when searching from the right
+    pub fn right_match(&self, commit: &Commit) -> bool {
+        match self {
+            Bound::Commit(sha) => commit.sha == **sha,
+            Bound::Date(date) => commit.is_master() && commit.date.0.date_naive() <= *date,
+            Bound::None => commit.is_master(),
+        }
+    }
+}
+
+impl serde::Serialize for Bound {
+    fn serialize<S>(&self, serializer: S) -> ::std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::ser::Serializer,
+    {
+        let s = match *self {
+            Bound::Commit(ref s) => s.clone(),
+            Bound::Date(ref date) => date.format("%Y-%m-%d").to_string(),
+            Bound::None => String::new(),
+        };
+        serializer.serialize_str(&s)
+    }
+}
+
+impl<'de> Deserialize<'de> for Bound {
+    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Bound, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        struct BoundVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for BoundVisitor {
+            type Value = Bound;
+
+            fn visit_str<E>(self, value: &str) -> ::std::result::Result<Bound, E>
+            where
+                E: serde::de::Error,
+            {
+                if value.is_empty() {
+                    return Ok(Bound::None);
+                }
+
+                let bound = value
+                    .parse::<chrono::NaiveDate>()
+                    .map(Bound::Date)
+                    .unwrap_or(Bound::Commit(value.to_string()));
+                Ok(bound)
+            }
+
+            fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                f.write_str("either a YYYY-mm-dd date or a collection ID (usually commit hash)")
+            }
+        }
+
+        deserializer.deserialize_str(BoundVisitor)
+    }
+}
+
 pub fn null_means_nan<'de, D>(deserializer: D) -> ::std::result::Result<f64, D::Error>
 where
     D: serde::de::Deserializer<'de>,
diff --git a/database/src/selector.rs b/database/src/selector.rs
@@ -24,107 +24,16 @@
 use std::{
     fmt::{self, Debug},
     hash::Hash,
-    ops::RangeInclusive,
     sync::Arc,
 };
 
 use async_trait::async_trait;
-use chrono::NaiveDate;
-use serde::Deserialize;
 
 use crate::{
     comparison::Metric, interpolate::Interpolate, ArtifactId, ArtifactIdIter, Benchmark,
-    CodegenBackend, Commit, Connection, Index, Lookup, Profile, Scenario,
+    CodegenBackend, Connection, Index, Lookup, Profile, Scenario,
 };
 
-/// The bound for finding an artifact
-///
-/// This can either be the upper or lower bound.
-/// In the case of commits or tags this is an exact bound, but for dates
-/// it's a best effort (i.e., if the bound is a date but there are no artifacts
-/// for that date, we'll find the artifact that most closely matches).
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
-pub enum Bound {
-    /// An unverified git commit (in sha form) or a tag of a commit (e.g., "1.53.0")
-    Commit(String),
-    /// A date in time
-    Date(NaiveDate),
-    /// No bound
-    #[default]
-    None,
-}
-
-impl Bound {
-    /// Tests whether `self` matches commit when searching from the left
-    pub fn left_match(&self, commit: &Commit) -> bool {
-        match self {
-            Bound::Commit(sha) => commit.sha == **sha,
-            Bound::Date(date) => commit.is_master() && commit.date.0.naive_utc().date() >= *date,
-            Bound::None => {
-                let last_month = chrono::Utc::now().date_naive() - chrono::Duration::days(30);
-                commit.is_master() && last_month <= commit.date.0.naive_utc().date()
-            }
-        }
-    }
-
-    /// Tests whether `self` matches commit when searching from the right
-    pub fn right_match(&self, commit: &Commit) -> bool {
-        match self {
-            Bound::Commit(sha) => commit.sha == **sha,
-            Bound::Date(date) => commit.is_master() && commit.date.0.date_naive() <= *date,
-            Bound::None => commit.is_master(),
-        }
-    }
-}
-
-impl serde::Serialize for Bound {
-    fn serialize<S>(&self, serializer: S) -> ::std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::ser::Serializer,
-    {
-        let s = match *self {
-            Bound::Commit(ref s) => s.clone(),
-            Bound::Date(ref date) => date.format("%Y-%m-%d").to_string(),
-            Bound::None => String::new(),
-        };
-        serializer.serialize_str(&s)
-    }
-}
-
-impl<'de> Deserialize<'de> for Bound {
-    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Bound, D::Error>
-    where
-        D: serde::de::Deserializer<'de>,
-    {
-        struct BoundVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for BoundVisitor {
-            type Value = Bound;
-
-            fn visit_str<E>(self, value: &str) -> ::std::result::Result<Bound, E>
-            where
-                E: serde::de::Error,
-            {
-                if value.is_empty() {
-                    return Ok(Bound::None);
-                }
-
-                let bound = value
-                    .parse::<chrono::NaiveDate>()
-                    .map(Bound::Date)
-                    .unwrap_or(Bound::Commit(value.to_string()));
-                Ok(bound)
-            }
-
-            fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                f.write_str("either a YYYY-mm-dd date or a collection ID (usually commit hash)")
-            }
-        }
-
-        deserializer.deserialize_str(BoundVisitor)
-    }
-}
-
 #[derive(Debug)]
 pub struct StatisticSeries {
     pub artifact_ids: ArtifactIdIter,
@@ -199,56 +108,6 @@ impl<T: Clone + PartialEq + fmt::Debug> Point for (T, f64) {
     }
 }
 
-/// Finds the most appropriate `ArtifactId` for a given bound.
-///
-/// Searches the commits in the index either from the left or the right.
-/// If not found in those commits, searches through the artifacts in the index.
-pub fn artifact_id_for_bound(data: &Index, bound: Bound, is_left: bool) -> Option<ArtifactId> {
-    let commits = data.commits();
-    let commit = if is_left {
-        commits
-            .iter()
-            .find(|commit| bound.left_match(commit))
-            .cloned()
-    } else {
-        commits
-            .iter()
-            .rfind(|commit| bound.right_match(commit))
-            .cloned()
-    };
-    commit.map(ArtifactId::Commit).or_else(|| {
-        data.artifacts()
-            .find(|aid| match &bound {
-                Bound::Commit(c) => *c == **aid,
-                Bound::Date(_) => false,
-                Bound::None => false,
-            })
-            .map(|aid| ArtifactId::Tag(aid.to_string()))
-    })
-}
-
-pub fn range_subset(data: Vec<Commit>, range: RangeInclusive<Bound>) -> Vec<Commit> {
-    let (a, b) = range.into_inner();
-
-    let left_idx = data.iter().position(|commit| a.left_match(commit));
-    let right_idx = data.iter().rposition(|commit| b.right_match(commit));
-
-    if let (Some(left), Some(right)) = (left_idx, right_idx) {
-        data.get(left..=right)
-            .map(|s| s.to_vec())
-            .unwrap_or_else(|| {
-                log::error!(
-                    "Failed to compute left/right indices from {:?}..={:?}",
-                    a,
-                    b
-                );
-                vec![]
-            })
-    } else {
-        vec![]
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum Selector<T> {
     All,
diff --git a/site/src/api.rs b/site/src/api.rs
@@ -81,7 +81,7 @@ pub mod dashboard {
 
 pub mod graph {
     use super::graphs::{GraphKind, Series};
-    use database::selector::Bound;
+    use collector::Bound;
     use serde::{Deserialize, Serialize};
 
     #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
@@ -102,7 +102,7 @@ pub mod graph {
 }
 
 pub mod graphs {
-    use database::selector::Bound;
+    use collector::Bound;
     use serde::{Deserialize, Serialize};
     use std::collections::{HashMap, HashSet};
 
@@ -147,7 +147,7 @@ pub mod graphs {
 pub mod detail_graphs {
     use crate::api::graphs::{GraphKind, Series};
     use crate::api::vec_from_comma_separated;
-    use database::selector::Bound;
+    use collector::Bound;
     use serde::{Deserialize, Serialize};
 
     #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
@@ -170,7 +170,7 @@ pub mod detail_graphs {
 }
 
 pub mod detail_sections {
-    use database::selector::Bound;
+    use collector::Bound;
     use serde::{Deserialize, Serialize};
 
     #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
@@ -207,7 +207,7 @@ pub mod detail_sections {
 pub mod runtime_detail_graphs {
     use crate::api::graphs::{GraphKind, Series};
     use crate::api::vec_from_comma_separated;
-    use database::selector::Bound;
+    use collector::Bound;
     use serde::{Deserialize, Serialize};
 
     #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
@@ -228,7 +228,7 @@ pub mod runtime_detail_graphs {
 }
 
 pub mod bootstrap {
-    use database::selector::Bound;
+    use collector::Bound;
     use hashbrown::HashMap;
     use serde::{Deserialize, Serialize};
 
@@ -252,7 +252,8 @@ pub mod bootstrap {
 
 pub mod comparison {
     use crate::benchmark_metadata::ProfileMetadata;
-    use database::{comparison::Metric, selector::Bound, Date};
+    use collector::Bound;
+    use database::{comparison::Metric, Date};
     use serde::{Deserialize, Serialize};
     use std::collections::HashMap;
 
@@ -593,8 +594,8 @@ pub mod github {
 }
 
 pub mod triage {
+    use collector::Bound;
     use database::comparison::Metric;
-    use database::selector::Bound;
     use serde::{Deserialize, Serialize};
 
     #[derive(Debug, Clone, Serialize, Deserialize)]
diff --git a/site/src/comparison.rs b/site/src/comparison.rs
@@ -17,8 +17,8 @@ use serde::Serialize;
 use crate::api::comparison::CompileBenchmarkMetadata;
 use crate::benchmark_metadata::get_compile_benchmarks_metadata;
 use crate::server::comparison::StatComparison;
-use collector::compile::benchmark::ArtifactType;
-use database::{selector::Bound, CodegenBackend, CommitType, CompileBenchmark};
+use collector::{compile::benchmark::ArtifactType, Bound};
+use database::{CodegenBackend, CommitType, CompileBenchmark};
 use std::cmp;
 use std::collections::{HashMap, HashSet};
 use std::error::Error;
diff --git a/site/src/github/comparison_summary.rs b/site/src/github/comparison_summary.rs
@@ -4,7 +4,7 @@ use crate::comparison::{
 };
 use crate::load::SiteCtxt;
 
-use database::selector::Bound;
+use collector::Bound;
 use database::{comparison::Metric, ArtifactId, QueuedCommit};
 
 use crate::github::{COMMENT_MARK_ROLLUP, COMMENT_MARK_TEMPORARY, RUST_REPO_GITHUB_API_URL};
diff --git a/site/src/load.rs b/site/src/load.rs
@@ -6,7 +6,6 @@ use std::time::Instant;
 
 use arc_swap::{ArcSwap, Guard};
 use chrono::{Duration, Utc};
-use database::selector::{self, Bound};
 use lazy_static::lazy_static;
 use log::error;
 use parking_lot::Mutex;
@@ -16,7 +15,7 @@ use serde::{Deserialize, Serialize};
 use crate::db;
 use crate::self_profile::SelfProfileCache;
 use collector::compile::benchmark::category::Category;
-use collector::MasterCommit;
+use collector::{Bound, MasterCommit};
 use database::Pool;
 pub use database::{ArtifactId, Benchmark, Commit};
 use database::{CommitType, Date};
@@ -149,11 +148,11 @@ impl SiteCtxt {
     }
 
     pub fn artifact_id_for_bound(&self, query: Bound, is_left: bool) -> Option<ArtifactId> {
-        selector::artifact_id_for_bound(&self.index.load(), query, is_left)
+        crate::selector::artifact_id_for_bound(&self.index.load(), query, is_left)
     }
 
     pub fn data_range(&self, range: RangeInclusive<Bound>) -> Vec<Commit> {
-        selector::range_subset(self.index.load().commits(), range)
+        crate::selector::range_subset(self.index.load().commits(), range)
     }
 
     /// Initialize `SiteCtxt` from database url
diff --git a/site/src/request_handlers/graph.rs b/site/src/request_handlers/graph.rs
diff --git a/site/src/selector.rs b/site/src/selector.rs
