new_run

Author: epompeii

Cargo.lock

@@ -65,13 +65,16 @@ async fn post_inner(
         .await?
     };
 
-    if let Some(auth_user) = auth_user.as_ref() {
-        query_project.try_allowed(&context.rbac, auth_user, Permission::Create)?;
-    } else if !query_project.is_unclaimed(conn_lock!(context))? {
-        return Err(unauthorized_error(format!(
-            "This project ({}) has already been claimed.",
-            query_project.slug
-        )));
+    // If a project is unclaimed, don't check permissions
+    if !query_project.is_unclaimed(conn_lock!(context))? {
+        if let Some(auth_user) = auth_user.as_ref() {
+            query_project.try_allowed(&context.rbac, auth_user, Permission::Create)?;
+        } else {
+            return Err(unauthorized_error(format!(
+                "This project ({}) has already been claimed.",
+                query_project.slug
+            )));
+        }
     }
     QueryReport::create(
         log,

lib/api_run/src/run.rs

@@ -14,7 +14,10 @@ const ROOT: &str = "root";
 #[allow(clippy::multiple_inherent_impl)]
 impl RunContext {
     pub fn current() -> Self {
-        get_context()
+        let mut context = RunContext::default();
+        git_context(&mut context);
+        platform_context(&mut context);
+        context
     }
 
     fn insert(&mut self, path: &str, value: String) -> Option<String> {
@@ -30,13 +33,6 @@ impl From<RunContext> for HashMap<String, String> {
     }
 }
 
-pub fn get_context() -> RunContext {
-    let mut context = RunContext::default();
-    git_context(&mut context);
-    platform_context(&mut context);
-    context
-}
-
 fn git_context(context: &mut RunContext) {
     let Some(repo) = find_repo() else {
         return;

lib/bencher_context/src/client/mod.rs

@@ -8,11 +8,7 @@ publish = false
 
 [features]
 default = ["plus"]
-plus = [
-    "bencher_client/plus",
-    "bencher_comment/plus",
-    "bencher_json/plus"
-]
+plus = ["bencher_client/plus", "bencher_comment/plus", "bencher_json/plus"]
 
 [build-dependencies]
 bencher_context = { workspace = true, features = ["client"] }
@@ -26,7 +22,6 @@ bencher_json = { workspace = true, features = ["client", "table"] }
 camino.workspace = true
 chrono = { workspace = true, features = ["clock"] }
 clap = { workspace = true, features = ["env"] }
-gix = { workspace = true, features = ["revision"] }
 literally.workspace = true
 octocrab.workspace = true
 progenitor-client.workspace = true

services/cli/Cargo.toml

@@ -1,14 +1,11 @@
-use bencher_json::{project::branch::BRANCH_MAIN_STR, GitHash, NameId};
+use bencher_json::{GitHash, NameId};
 
-use crate::{
-    bencher::sub::project::branch::start_point::StartPoint,
-    parser::run::{CliRunBranch, CliRunHash},
-};
+use crate::{bencher::sub::project::branch::start_point::StartPoint, parser::run::CliRunBranch};
 
 #[allow(clippy::struct_field_names)]
 #[derive(Debug, Clone)]
 pub struct Branch {
-    branch: NameId,
+    branch: Option<NameId>,
     hash: Option<GitHash>,
     start_point: StartPoint,
 }
@@ -33,8 +30,6 @@ impl TryFrom<CliRunBranch> for Branch {
             start_point_reset,
             deprecated: _,
         } = run_branch;
-        let branch = try_branch(branch)?;
-        let hash = map_hash(hash);
         let start_point = map_start_point(
             start_point,
             start_point_hash,
@@ -50,47 +45,6 @@ impl TryFrom<CliRunBranch> for Branch {
     }
 }
 
-fn try_branch(branch: Option<NameId>) -> Result<NameId, BranchError> {
-    if let Some(branch) = branch {
-        Ok(branch)
-    } else if let Some(branch) = find_branch() {
-        Ok(branch)
-    } else {
-        BRANCH_MAIN_STR.parse().map_err(BranchError::ParseBranch)
-    }
-}
-
-fn find_branch() -> Option<NameId> {
-    if let Some(repo) = find_repo() {
-        if let Ok(Some(branch)) = repo.head_name() {
-            return branch.shorten().to_string().parse().ok();
-        }
-    }
-    None
-}
-
-fn map_hash(CliRunHash { hash, no_hash }: CliRunHash) -> Option<GitHash> {
-    if let Some(hash) = hash {
-        return Some(hash);
-    } else if no_hash {
-        return None;
-    }
-    let repo = find_repo()?;
-    let head_id = repo.head_id().ok()?;
-    let head_object = head_id.object().ok()?;
-    Some(head_object.id.into())
-}
-
-pub fn find_repo() -> Option<gix::Repository> {
-    let current_dir = std::env::current_dir().ok()?;
-    for directory in current_dir.ancestors() {
-        if let Ok(repo) = gix::open(directory) {
-            return Some(repo);
-        }
-    }
-    None
-}
-
 #[allow(clippy::needless_pass_by_value)]
 fn map_start_point(
     start_point: Vec<String>,
@@ -115,13 +69,13 @@ fn map_start_point(
 
 impl From<Branch>
     for (
-        bencher_client::types::NameId,
+        Option<bencher_client::types::NameId>,
         Option<bencher_client::types::GitHash>,
         Option<bencher_client::types::JsonUpdateStartPoint>,
     )
 {
     fn from(branch: Branch) -> Self {
-        let name = branch.branch.into();
+        let name = branch.branch.map(Into::into);
         let hash = branch.hash.map(Into::into);
         let start_point = branch.start_point.into();
         (name, hash, start_point)

services/cli/src/bencher/sub/run/branch.rs

@@ -1,11 +1,11 @@
 use std::{future::Future, pin::Pin};
 
-use bencher_client::types::{Adapter, JsonAverage, JsonFold, JsonNewReport, JsonReportSettings};
+use bencher_client::types::{Adapter, JsonAverage, JsonFold, JsonNewRun, JsonReportSettings};
 use bencher_comment::ReportComment;
-use bencher_json::{DateTime, JsonReport, NameId, ResourceId};
+use bencher_json::{DateTime, JsonReport, NameId, ResourceId, RunContext};
 
 use crate::{
-    bencher::backend::AuthBackend,
+    bencher::backend::PubBackend,
     cli_eprintln_quietable, cli_println, cli_println_quietable,
     parser::run::{CliRun, CliRunOutput},
     CliError,
@@ -32,9 +32,9 @@ use super::project::report::Thresholds;
 #[derive(Debug)]
 #[allow(clippy::struct_excessive_bools)]
 pub struct Run {
-    project: ResourceId,
+    project: Option<ResourceId>,
     branch: Branch,
-    testbed: NameId,
+    testbed: Option<NameId>,
     adapter: Adapter,
     sub_adapter: SubAdapter,
     average: Option<JsonAverage>,
@@ -50,7 +50,7 @@ pub struct Run {
     runner: Runner,
     #[allow(clippy::struct_field_names)]
     dry_run: bool,
-    backend: AuthBackend,
+    backend: PubBackend,
 }
 
 impl TryFrom<CliRun> for Run {
@@ -76,9 +76,9 @@ impl TryFrom<CliRun> for Run {
             backend,
         } = run;
         Ok(Self {
-            project,
+            project: project.map(Into::into),
             branch: branch.try_into().map_err(RunError::Branch)?,
-            testbed,
+            testbed: testbed.map(Into::into),
             adapter: adapter.into(),
             sub_adapter: (&cmd).into(),
             average: average.map(Into::into),
@@ -93,7 +93,7 @@ impl TryFrom<CliRun> for Run {
             ci: ci.try_into().map_err(RunError::Ci)?,
             runner: cmd.try_into()?,
             dry_run,
-            backend: AuthBackend::try_from(backend)?.log(false),
+            backend: PubBackend::try_from(backend)?.log(false),
         })
     }
 }
@@ -119,23 +119,23 @@ impl Run {
             ci.safety_check(self.log)?;
         }
 
-        let Some(json_new_report) = self.generate_report().await? else {
+        let Some(json_new_run) = self.generate_report().await? else {
             return Ok(());
         };
 
         cli_println_quietable!(self.log, "\nBencher New Report:");
         cli_println_quietable!(
             self.log,
             "{}",
-            serde_json::to_string_pretty(&json_new_report).map_err(RunError::SerializeReport)?
+            serde_json::to_string_pretty(&json_new_run).map_err(RunError::SerializeReport)?
         );
 
         // If performing a dry run, don't actually send the report
         if self.dry_run {
             return Ok(());
         }
 
-        let sender = report_sender(self.project.clone(), json_new_report);
+        let sender = run_sender(json_new_run);
         let json_report: JsonReport = self
             .backend
             .send_with(sender)
@@ -152,7 +152,7 @@ impl Run {
         }
     }
 
-    async fn generate_report(&self) -> Result<Option<JsonNewReport>, RunError> {
+    async fn generate_report(&self) -> Result<Option<JsonNewRun>, RunError> {
         let start_time = DateTime::now();
         let mut results = Vec::with_capacity(self.iter);
         for _ in 0..self.iter {
@@ -184,11 +184,12 @@ impl Run {
         };
 
         let (branch, hash, start_point) = self.branch.clone().into();
-        Ok(Some(JsonNewReport {
+        Ok(Some(JsonNewRun {
+            project: self.project.clone().map(Into::into),
             branch,
             hash,
             start_point,
-            testbed: self.testbed.clone().into(),
+            testbed: self.testbed.clone().map(Into::into),
             thresholds: self.thresholds.clone().into(),
             start_time: start_time.into(),
             end_time: end_time.into(),
@@ -198,8 +199,7 @@ impl Run {
                 average: self.average,
                 fold: self.fold,
             }),
-            // TODO add context when we move over to JsonNewRun
-            // context: Some(RunContext::current().into()),
+            context: Some(RunContext::current().into()),
         }))
     }
 
@@ -242,20 +242,11 @@ type ReportResult = Pin<
             > + Send,
     >,
 >;
-fn report_sender(
-    project: ResourceId,
-    json_new_report: JsonNewReport,
+fn run_sender(
+    json_new_run: JsonNewRun,
 ) -> Box<dyn Fn(bencher_client::Client) -> ReportResult + Send> {
     Box::new(move |client: bencher_client::Client| {
-        let project = project.clone();
-        let json_new_report = json_new_report.clone();
-        Box::pin(async move {
-            client
-                .proj_report_post()
-                .project(project.clone())
-                .body(json_new_report.clone())
-                .send()
-                .await
-        })
+        let json_new_run = json_new_run.clone();
+        Box::pin(async move { client.run_post().body(json_new_run.clone()).send().await })
     })
 }

services/cli/src/bencher/sub/run/mod.rs

@@ -1,6 +1,4 @@
-use bencher_json::{
-    project::testbed::TESTBED_LOCALHOST_STR, DateTime, GitHash, NameId, ResourceId,
-};
+use bencher_json::{DateTime, GitHash, NameId, ResourceId};
 use camino::Utf8PathBuf;
 use clap::{ArgGroup, Args, Parser, ValueEnum};
 
@@ -15,15 +13,15 @@ use super::project::report::{
 pub struct CliRun {
     /// Project slug or UUID
     #[clap(long, env = "BENCHER_PROJECT")]
-    pub project: ResourceId,
+    pub project: Option<ResourceId>,
 
     #[clap(flatten)]
     pub branch: CliRunBranch,
 
     /// Testbed name, slug, or UUID.
     /// If a name or slug is provided, the testbed will be created if it does not exist.
-    #[clap(long, env = "BENCHER_TESTBED", default_value = TESTBED_LOCALHOST_STR)]
-    pub testbed: NameId,
+    #[clap(long, env = "BENCHER_TESTBED")]
+    pub testbed: Option<NameId>,
 
     /// Benchmark harness adapter
     #[clap(value_enum, long, env = "BENCHER_ADAPTER", default_value = "magic")]
@@ -83,8 +81,9 @@ pub struct CliRunBranch {
     #[clap(long, env = "BENCHER_BRANCH", alias = "if-branch")]
     pub branch: Option<NameId>,
 
-    #[clap(flatten)]
-    pub hash: CliRunHash,
+    /// `git` commit hash (default HEAD)
+    #[clap(long)]
+    pub hash: Option<GitHash>,
 
     /// Use the specified branch name, slug, or UUID as the start point for `branch`.
     /// If `branch` already exists and the start point is different, a new branch will be created.
@@ -115,26 +114,16 @@ pub struct CliRunBranch {
     pub start_point_reset: bool,
 
     /// Deprecated: Do not use. This will soon be removed.
-    #[clap(long, hide = true, alias = "else-branch", alias = "endif-branch")]
+    #[clap(
+        long,
+        hide = true,
+        alias = "else-branch",
+        alias = "endif-branch",
+        alias = "no-hash"
+    )]
     pub deprecated: bool,
 }
 
-#[derive(Args, Debug)]
-#[clap(group(
-    ArgGroup::new("run_hash")
-        .multiple(false)
-        .args(&["hash", "no_hash"]),
-))]
-pub struct CliRunHash {
-    /// `git` commit hash (default HEAD)
-    #[clap(long)]
-    pub hash: Option<GitHash>,
-
-    /// Do not try to find a `git` commit hash
-    #[clap(long)]
-    pub no_hash: bool,
-}
-
 #[derive(Args, Debug)]
 pub struct CliRunCommand {
     /// Track the build time of the benchmark command

services/cli/src/parser/run.rs

@@ -1,3 +1,6 @@
+## Pending `v0.5.0`
+- Allow `bencher run` to create a project if it does not exist for both authenticated and anonymous users
+
 ## `v0.4.37`
 - Add dimension search in Threshold creation UI
 - Add Threshold list to Branch, Testbed, and Measure pages in Console UI