run

Author: epompeii

lib/bencher_json/src/lib.rs

@@ -19,6 +19,7 @@ pub mod big_int;
 pub mod organization;
 pub mod pagination;
 pub mod project;
+pub mod run;
 pub mod system;
 pub(crate) mod typed_uuid;
 pub mod urlencoded;
@@ -52,6 +53,7 @@ pub use project::{
     threshold::{JsonNewThreshold, JsonThreshold, JsonThresholds, ThresholdUuid},
     JsonNewProject, JsonProject, JsonProjects, ProjectUuid,
 };
+pub use run::JsonNewRun;
 #[cfg(feature = "plus")]
 pub use system::{
     auth::JsonOAuth,

lib/bencher_json/src/project/branch.rs

@@ -14,7 +14,7 @@ pub const START_POINT_MAX_VERSIONS: u32 = 255;
 
 pub const BRANCH_MAIN_STR: &str = "main";
 #[allow(clippy::expect_used)]
-static BRANCH_MAIN: LazyLock<BranchName> = LazyLock::new(|| {
+pub static BRANCH_MAIN: LazyLock<BranchName> = LazyLock::new(|| {
     BRANCH_MAIN_STR
         .parse()
         .expect("Failed to parse branch name.")

lib/bencher_json/src/project/testbed.rs

@@ -10,7 +10,7 @@ use crate::ProjectUuid;
 
 pub const TESTBED_LOCALHOST_STR: &str = "localhost";
 #[allow(clippy::expect_used)]
-static TESTBED_LOCALHOST: LazyLock<ResourceName> = LazyLock::new(|| {
+pub static TESTBED_LOCALHOST: LazyLock<ResourceName> = LazyLock::new(|| {
     TESTBED_LOCALHOST_STR
         .parse()
         .expect("Failed to parse testbed name.")

lib/bencher_json/src/run/mod.rs

@@ -0,0 +1,135 @@
+use bencher_valid::{BranchName, DateTime, Fingerprint, GitHash, ResourceId};
+#[cfg(feature = "schema")]
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    project::{
+        branch::{JsonUpdateStartPoint, BRANCH_MAIN},
+        report::{JsonReportSettings, JsonReportThresholds},
+        testbed::TESTBED_LOCALHOST,
+    },
+    JsonNewReport, NameId,
+};
+
+crate::typed_uuid::typed_uuid!(ReportUuid);
+
+#[derive(Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schema", derive(JsonSchema))]
+pub struct JsonNewRun {
+    /// Organization UUID or slug.
+    pub organization: Option<ResourceId>,
+    /// Project UUID, slug, or name.
+    pub project: Option<NameId>,
+    /// Branch UUID, slug, or name.
+    /// If the branch does not exist, it will be created.
+    pub branch: Option<NameId>,
+    /// Full `git` commit hash.
+    /// All reports with the same `git` commit hash will be considered part of the same branch version.
+    /// This can be useful for tracking the performance of a specific commit across multiple testbeds.
+    pub hash: Option<GitHash>,
+    /// The start point for the report branch.
+    /// If the branch does not exist, the start point will be used to create a new branch.
+    /// If the branch already exists and the start point is not provided, the current branch will be used.
+    /// If the branch already exists and the start point provided is different, a new branch head will be created from the new start point.
+    /// If a new branch or new branch head is created with a start point,
+    /// historical branch versions from the start point branch will be shallow copied over to the new branch.
+    /// That is, historical metrics data for the start point branch will appear in queries for the branch.
+    /// For example, pull request branches often use their base branch as their start point branch.
+    /// If a new branch is created, it is not kept in sync with the start point branch.
+    pub start_point: Option<JsonUpdateStartPoint>,
+    /// Testbed UUID, slug, or name.
+    /// If the testbed does not exist, it will be created.
+    pub testbed: Option<NameId>,
+    /// Thresholds to use for the branch, testbed, and measures in the report.
+    /// If a threshold does not exist, it will be created.
+    /// If a threshold exists and the model is different, it will be updated with the new model.
+    /// If a measure name or slug is provided, the measure will be created if it does not exist.
+    pub thresholds: Option<JsonReportThresholds>,
+    /// Start time for the report. Must be an ISO 8601 formatted string.
+    pub start_time: DateTime,
+    /// End time for the report. Must be an ISO 8601 formatted string.
+    pub end_time: DateTime,
+    /// An array of benchmarks results.
+    pub results: Vec<String>,
+    /// Settings for how to handle the report.
+    pub settings: Option<JsonReportSettings>,
+    /// Context for the run.
+    pub context: Option<JsonRunContext>,
+}
+
+impl From<JsonNewRun> for JsonNewReport {
+    fn from(run: JsonNewRun) -> Self {
+        let JsonNewRun {
+            organization: _,
+            project: _,
+            branch,
+            hash,
+            start_point,
+            testbed,
+            thresholds,
+            start_time,
+            end_time,
+            results,
+            settings,
+            context,
+        } = run;
+        let branch = branch
+            .or_else(|| {
+                context
+                    .as_ref()
+                    .and_then(|ctx| ctx.branch.clone().map(Into::into))
+            })
+            .unwrap_or_else(|| BRANCH_MAIN.clone().into());
+        let testbed = testbed
+            .or_else(|| {
+                context
+                    .as_ref()
+                    .and_then(|ctx| ctx.os.and_then(|os| os.as_ref().parse().ok()))
+            })
+            .unwrap_or_else(|| TESTBED_LOCALHOST.clone().into());
+        Self {
+            branch,
+            hash,
+            start_point,
+            testbed,
+            thresholds,
+            start_time,
+            end_time,
+            results,
+            settings,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schema", derive(JsonSchema))]
+pub struct JsonRunContext {
+    /// The branch during the run.
+    pub branch: Option<BranchName>,
+    /// The root commit hash during the run.
+    pub root_commit: Option<GitHash>,
+    /// The testbed operating system during the run.
+    pub os: Option<OperatingSystem>,
+    /// The testbed fingerprint during the run.
+    pub fingerprint: Option<Fingerprint>,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[cfg_attr(feature = "schema", derive(JsonSchema))]
+#[serde(rename_all = "snake_case")]
+pub enum OperatingSystem {
+    Linux,
+    Macos,
+    Windows,
+}
+
+impl AsRef<str> for OperatingSystem {
+    fn as_ref(&self) -> &str {
+        match self {
+            Self::Linux => "linux",
+            Self::Macos => "macos",
+            Self::Windows => "windows",
+        }
+    }
+}

lib/bencher_valid/Cargo.toml

@@ -11,7 +11,7 @@ crate-type = ["cdylib", "rlib"]
 
 [features]
 full = ["dep:rand", "dep:regex"]
-lite = ["dep:regex-lite"]
+lite = ["dep:regex-lite", "dep:windows"]
 db = ["dep:diesel"]
 plus = ["chrono/clock"]
 schema = ["dep:schemars", "ordered-float/schemars"]

lib/bencher_valid/src/name_id.rs

@@ -11,7 +11,7 @@ use serde::{
 };
 use uuid::Uuid;
 
-use crate::{non_empty::is_valid_non_empty, NonEmpty, Slug, ValidError};
+use crate::{non_empty::is_valid_non_empty, BranchName, NonEmpty, ResourceName, Slug, ValidError};
 
 #[typeshare::typeshare]
 #[derive(Debug, derive_more::Display, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
@@ -76,6 +76,18 @@ impl From<NonEmpty> for NameId {
     }
 }
 
+impl From<ResourceName> for NameId {
+    fn from(resource_name: ResourceName) -> Self {
+        Self(resource_name.into())
+    }
+}
+
+impl From<BranchName> for NameId {
+    fn from(branch_name: BranchName) -> Self {
+        Self(branch_name.into())
+    }
+}
+
 impl AsRef<str> for NameId {
     fn as_ref(&self) -> &str {
         &self.0