get_or_create_from_context

Author: epompeii

lib/api_run/src/run.rs

@@ -1,15 +1,10 @@
 use bencher_endpoint::{CorsResponse, Endpoint, Post, ResponseCreated};
-use bencher_json::{
-    project, system::auth, JsonNewOrganization, JsonNewRun, JsonReport, NameIdKind, ResourceName,
-    RunContext,
-};
+use bencher_json::{JsonNewRun, JsonReport, RunContext};
 use bencher_rbac::project::Permission;
 use bencher_schema::{
-    conn_lock,
     context::ApiContext,
     error::{bad_request_error, forbidden_error, issue_error},
     model::{
-        organization::QueryOrganization,
         project::{report::QueryReport, QueryProject},
         user::auth::{AuthUser, PubBearerToken},
     },
@@ -61,15 +56,25 @@ async fn post_inner(
             (auth_user, query_project)
         },
         (Some(auth_user), None) => {
+            let Some(project_name) = json_run.context.as_ref().and_then(RunContext::name) else {
+                return Err(bad_request_error(
+                    "The `project` field was not specified nor was a run `context` provided for the name",
+                ));
+            };
             let Some(project_slug) = json_run.context.as_ref().map(RunContext::slug) else {
                 return Err(bad_request_error(
-                    "The `project` field was not specified nor was a run `context` provided",
+                    "The `project` field was not specified nor was a run `context` provided for the slug",
                 ));
             };
-            let query_project =
-                QueryProject::get_or_create(log, context, &auth_user, &project_slug.into())
-                    .await
-                    .map_err(|e| forbidden_error(e.to_string()))?;
+            let query_project = QueryProject::get_or_create_from_context(
+                log,
+                context,
+                &auth_user,
+                project_name,
+                project_slug,
+            )
+            .await
+            .map_err(|e| forbidden_error(e.to_string()))?;
             (auth_user, query_project)
         },
         _ => return Err(bad_request_error("Not yet supported")),

lib/bencher_context/Cargo.toml

@@ -8,7 +8,7 @@ publish = false
 
 [features]
 client = ["dep:gix", "dep:uuid", "dep:windows"]
-server = ["dep:uuid", "bencher_valid/server"]
+server = ["dep:uuid", "bencher_valid/server", "uuid/v4"]
 schema = ["dep:schemars"]
 
 [dependencies]

lib/bencher_context/src/server/mod.rs

@@ -1,4 +1,4 @@
-use bencher_valid::{Slug, MAX_LEN};
+use bencher_valid::{ResourceName, Slug};
 use uuid::Uuid;
 
 use crate::{ContextPath, RunContext};
@@ -40,14 +40,32 @@ impl RunContext {
         self.get(ContextPath::TESTBED_FINGERPRINT)?.parse().ok()
     }
 
+    pub fn name(&self) -> Option<ResourceName> {
+        self.repo_name()
+            .map(truncate_name)
+            .or_else(|| {
+                self.repo_hash()
+                    .map(short_hash)
+                    .map(|hash| format!("Project ({hash})"))
+            })
+            .or_else(|| {
+                self.testbed_fingerprint()
+                    .map(base36::encode_uuid)
+                    .as_deref()
+                    .map(short_fingerprint)
+                    .map(|fingerprint| format!("My Project ({fingerprint})"))
+            })
+            .unwrap_or_else(|| {
+                let id = short_fingerprint(&base36::encode_uuid(Uuid::new_v4()));
+                format!("New Project ({id})")
+            })
+            .parse()
+            .ok()
+    }
+
     pub fn slug(&self) -> Slug {
-        // + 42 chars
-        let name = self.repo_name().map(truncate_name).unwrap_or_default();
-        // + 1 char (-)
-        // + 7 chars
+        let name = self.repo_name().map(short_name).unwrap_or_default();
         let hash = self.repo_hash().map(short_hash).unwrap_or_default();
-        // + 1 char (-)
-        // + 13 chars
         let fingerprint = self
             .testbed_fingerprint()
             .map(base36::encode_uuid)
@@ -58,19 +76,34 @@ impl RunContext {
         // in case any of the values are empty
         // they will essentially be ignored
         let slug = format!("{name} {hash} {fingerprint}");
-        debug_assert!(slug.len() <= MAX_LEN, "Slug is too long: {slug}");
+        debug_assert!(slug.len() <= Slug::MAX_LEN, "Slug is too long: {slug}");
         Slug::new(slug)
     }
 }
 
 fn truncate_name(name: &str) -> String {
-    name.chars().take(42).collect()
+    name.chars().take(ResourceName::MAX_LEN).collect()
+}
+
+const SHORT_NAME_LEN: usize = 42;
+const SHORT_HASH_LEN: usize = 7;
+const SHORT_FINGERPRINT_LEN: usize = 13;
+#[allow(dead_code)]
+const DASH_LEN: usize = 1;
+
+// Statically assert that the sum of the lengths of the short names
+// is less than or equal to the maximum length of a slug
+const _: [(); SHORT_NAME_LEN + DASH_LEN + SHORT_HASH_LEN + DASH_LEN + SHORT_FINGERPRINT_LEN] =
+    [(); Slug::MAX_LEN];
+
+fn short_name(name: &str) -> String {
+    name.chars().take(SHORT_NAME_LEN).collect()
 }
 
 fn short_hash(hash: &str) -> String {
-    hash.chars().take(7).collect()
+    hash.chars().take(SHORT_HASH_LEN).collect()
 }
 
 fn short_fingerprint(fingerprint: &str) -> String {
-    fingerprint.chars().take(13).collect()
+    fingerprint.chars().take(SHORT_FINGERPRINT_LEN).collect()
 }

lib/bencher_schema/src/model/project/mod.rs

@@ -15,8 +15,8 @@ use crate::{
     conn_lock,
     context::{DbConnection, Rbac},
     error::{
-        assert_parentage, forbidden_error, resource_conflict_err, resource_not_found_error,
-        unauthorized_error, BencherResource,
+        assert_parentage, forbidden_error, resource_conflict_err, resource_not_found_err,
+        resource_not_found_error, unauthorized_error, BencherResource,
     },
     macros::{
         fn_get::{fn_from_uuid, fn_get, fn_get_uuid},
@@ -74,6 +74,13 @@ impl QueryProject {
         Project
     );
 
+    fn from_slug(conn: &mut DbConnection, slug: &Slug) -> Result<Self, HttpError> {
+        schema::project::table
+            .filter(schema::project::slug.eq(slug))
+            .first(conn)
+            .map_err(resource_not_found_err!(Project, slug.clone()))
+    }
+
     pub async fn get_or_create(
         log: &Logger,
         context: &ApiContext,
@@ -105,6 +112,27 @@ impl QueryProject {
         Self::create(log, context, auth_user, &query_organization, json_project).await
     }
 
+    pub async fn get_or_create_from_context(
+        log: &Logger,
+        context: &ApiContext,
+        auth_user: &AuthUser,
+        project_name: ResourceName,
+        project_slug: Slug,
+    ) -> Result<Self, HttpError> {
+        if let Ok(query_project) = Self::from_slug(conn_lock!(context), &project_slug) {
+            return Ok(query_project);
+        }
+
+        let query_organization = QueryOrganization::get_or_create(context, auth_user).await?;
+        let json_project = JsonNewProject {
+            name: project_name,
+            slug: Some(project_slug),
+            url: None,
+            visibility: None,
+        };
+        Self::create(log, context, auth_user, &query_organization, json_project).await
+    }
+
     pub async fn create(
         log: &Logger,
         context: &ApiContext,