feat(mono): Support automatically creating a CL and triggering the build process after editing files. (#1892)

Signed-off-by: Chen-Rong-Zi <1398881912@qq.com>

Author: Chen-Rong-Zi

ceres/src/api_service/commit_ops.rs

@@ -454,7 +454,7 @@ pub async fn traverse_history_commits<T: ApiHandler + ?Sized>(
 
     // Final sort: by committer timestamp descending
     let mut result = matched_by_author;
-    result.sort_by(|a, b| b.committer.timestamp.cmp(&a.committer.timestamp));
+    result.sort_by_key(|b| std::cmp::Reverse(b.committer.timestamp));
     Ok(result)
 }
 

ceres/src/api_service/import_api_service.rs

@@ -469,6 +469,7 @@ impl ApiHandler for ImportApiService {
             commit_id: new_commit_id,
             new_oid: new_blob.id.to_string(),
             path: payload.path,
+            cl_link: None,
         })
     }
 }

ceres/src/api_service/mono_api_service.rs

@@ -45,8 +45,10 @@ use std::{
 
 use api_model::common::Pagination;
 use async_trait::async_trait;
+use bellatrix::Bellatrix;
 use bytes::Bytes;
 use callisto::{
+    entity_ext::generate_link,
     mega_cl, mega_refs, mega_tag, mega_tree,
     sea_orm_active_enums::{ConvTypeEnum, MergeStatusEnum, QueueFailureTypeEnum, QueueStatusEnum},
 };
@@ -89,13 +91,14 @@ use crate::{
         ApiHandler, buck_tree_builder::BuckCommitBuilder, cache::GitObjectCache,
         state::ProtocolApiState, tree_ops,
     },
+    build_trigger::BuildTriggerService,
     model::{
         buck::{
             CompletePayload, CompleteResponse, DEFAULT_MODE, FileChange,
             FileToUpload as ApiFileToUpload, ManifestPayload, ManifestResponse,
         },
         change_list::{ClDiffFile, UpdateBranchStatusRes},
-        git::{CreateEntryInfo, EditFilePayload, EditFileResult},
+        git::{CreateEntryInfo, EditCLMode, EditFilePayload, EditFileResult},
         tag::TagInfo,
         third_party::{ThirdPartyClient, ThirdPartyRepoTrait},
     },
@@ -398,15 +401,34 @@ impl ApiHandler for MonoApiService {
             .apply_update_result(&result, &payload.commit_message, None)
             .await?;
 
+        let username = payload
+            .author_username
+            .clone()
+            .unwrap_or("Anonymous".to_string());
+
+        let cl = self
+            .find_or_create_cl_for_edit(
+                payload.mode,
+                &new_commit_id,
+                &payload.commit_message,
+                &payload.path,
+                &username,
+            )
+            .await?;
         self.storage
             .mono_service
             .save_blobs(&new_commit_id, vec![new_blob.clone()])
             .await?;
 
+        if !payload.skip_build {
+            self.trigger_build_for_cl(&cl.link).await?;
+        }
+
         Ok(EditFileResult {
             commit_id: new_commit_id,
             new_oid: new_blob.id.to_string(),
             path: payload.path,
+            cl_link: Some(cl.link),
         })
     }
 
@@ -1027,6 +1049,145 @@ impl MonoApiService {
         }
     }
 
+    async fn create_new_cl(
+        &self,
+        repo_path: &str,
+        commit_message: &str,
+        to_hash: &str,
+        username: &str,
+    ) -> Result<mega_cl::Model, GitError> {
+        let cl_link = generate_link();
+
+        let from_hash = self
+            .storage
+            .mono_storage()
+            .get_main_ref(repo_path)
+            .await?
+            .ok_or_else(|| MegaError::Other("Main ref not found".to_string()))?
+            .ref_commit_hash;
+
+        // Create and return a new CL model
+        let cl = self
+            .storage
+            .cl_storage()
+            .new_cl_model(
+                repo_path,
+                &cl_link,
+                commit_message,
+                &from_hash,
+                to_hash,
+                username,
+            )
+            .await
+            .map_err(|e| GitError::CustomError(format!("Failed to create CL: {}", e)))?;
+
+        Ok(cl)
+    }
+
+    /// Finds or creates a Change List (CL) for file edits.
+    /// This method determines whether to create a new CL or reuse an existing one based on the
+    /// [`EditCLMode`] passed in `mode`. For example, `EditCLMode::ForceCreate` will always create
+    /// a new CL, while `EditCLMode::TryReuse` will attempt to find an open CL for the given user
+    /// and path and only create a new one if none exists.
+    ///
+    /// # Arguments
+    /// * `mode` - Controls whether to force creation of a new CL (`ForceCreate`) or try to reuse an
+    ///   existing open CL for the user and path when possible (`TryReuse`).
+    /// * `to_hash` - The commit hash representing the new state after the edit.
+    /// * `commit_message` - The message describing the changes made in the CL.
+    /// * `file_path` - The path of the file being edited.
+    /// * `username` - The username of the user performing the edit.
+    ///
+    /// # Returns
+    /// A `Result` containing the `mega_cl::Model` representing the found or created CL on success,
+    /// or a `GitError` on failure.
+    async fn find_or_create_cl_for_edit(
+        &self,
+        mode: EditCLMode,
+        to_hash: &str,
+        commit_message: &str,
+        file_path: &str,
+        username: &str,
+    ) -> Result<mega_cl::Model, GitError> {
+        let path = PathBuf::from(file_path);
+        let repo_path = path
+            .parent()
+            .map(|p| p.to_string_lossy().to_string())
+            .unwrap_or_else(|| "/".to_string());
+
+        let storage = self.storage.cl_storage();
+        match mode {
+            EditCLMode::ForceCreate => {
+                self.create_new_cl(&repo_path, commit_message, to_hash, username)
+                    .await
+            }
+            EditCLMode::TryReuse(None) => {
+                if let Some(existing_cl) =
+                    storage
+                        .get_open_cl_by_path(&repo_path, username)
+                        .await
+                        .map_err(|e| GitError::CustomError(format!("Failed to fetch CL: {}", e)))?
+                {
+                    storage
+                        .update_cl_to_hash(existing_cl.clone(), to_hash)
+                        .await?;
+                    Ok(existing_cl)
+                } else {
+                    self.create_new_cl(&repo_path, commit_message, to_hash, username)
+                        .await
+                }
+            }
+            EditCLMode::TryReuse(Some(link)) => {
+                match self.storage.cl_storage().get_cl(&link).await {
+                    Ok(Some(model)) => {
+                        storage.update_cl_to_hash(model.clone(), to_hash).await?;
+                        Ok(model)
+                    }
+                    _ => {
+                        self.create_new_cl(&repo_path, commit_message, to_hash, username)
+                            .await
+                    }
+                }
+            }
+        }
+    }
+
+    /// Triggers a build for the specified Change List (CL).
+    /// It spawns a background task to handle the build process, ensuring that the main application flow remains responsive.
+    /// # Arguments
+    /// * `cl_link` - The unique identifier (link) of the CL for which the build is to be triggered.
+    ///
+    /// # Returns
+    /// A `Result` indicating success or failure. Returns `Ok(())` if the build was successfully triggered,
+    /// or a `GitError` if an error occurred during the process.
+    async fn trigger_build_for_cl(&self, cl_link: &str) -> Result<(), GitError> {
+        let config = self.storage.config();
+        let bellatrix = Bellatrix::new(config.build.clone());
+        let cl = self
+            .storage
+            .cl_storage()
+            .get_cl(cl_link)
+            .await
+            .map_err(|e| GitError::CustomError(format!("Failed to get CL: {}", e)))?
+            .ok_or_else(|| GitError::CustomError("CL not found".to_string()))?;
+
+        let storage = self.storage.clone();
+        let git_cache = self.git_object_cache.clone();
+
+        // Spawn a background task to handle the build process
+        tokio::spawn(async move {
+            let _ = BuildTriggerService::build_by_context(
+                storage,
+                git_cache,
+                Arc::new(bellatrix),
+                cl.into(),
+            )
+            .await;
+        });
+
+        Ok(())
+    }
+
     async fn create_annotated_tag_mono(
         &self,
         repo_path: Option<String>,

ceres/src/build_trigger/dispatcher.rs

@@ -55,6 +55,7 @@ impl BuildDispatcher {
             BuildTriggerPayload::Retry(p) => (&p.cl_link, &p.repo, &p.builds, p.cl_id),
             BuildTriggerPayload::Webhook(p) => (&p.cl_link, &p.repo, &p.builds, p.cl_id),
             BuildTriggerPayload::Schedule(p) => (&p.cl_link, &p.repo, &p.builds, p.cl_id),
+            BuildTriggerPayload::WebEdit(p) => (&p.cl_link, &p.repo, &p.builds, p.cl_id),
         };
 
         let builds: Vec<SerializableBuildInfo> = serde_json::from_value(builds_json.clone())

ceres/src/build_trigger/mod.rs

@@ -14,6 +14,7 @@ mod manual_handler;
 mod model;
 mod ref_resolver;
 mod retry_handler;
+mod web_edit_handler;
 
 // Export all models from the single model file
 pub use model::*;
@@ -24,6 +25,7 @@ use git_push_handler::GitPushHandler;
 use manual_handler::ManualHandler;
 use retry_handler::RetryHandler;
 pub use service::BuildTriggerService;
+use web_edit_handler::WebEditHandler;
 
 /// Trait for handling different types of build triggers.
 #[async_trait]
@@ -66,6 +68,10 @@ impl TriggerRegistry {
             storage.clone(),
             git_object_cache.clone(),
         )));
+        registry.register(Box::new(WebEditHandler::new(
+            storage.clone(),
+            git_object_cache.clone(),
+        )));
 
         // Note: Webhook and Schedule handlers are reserved for future implementation
         // but not registered yet as they are not part of the current requirements

ceres/src/build_trigger/model.rs

@@ -1,5 +1,6 @@
 use std::{collections::HashMap, fmt};
 
+use callisto::mega_cl;
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 use utoipa::ToSchema;
@@ -12,6 +13,7 @@ pub enum BuildTriggerType {
     Retry,
     Webhook,
     Schedule,
+    WebEdit,
 }
 
 impl fmt::Display for BuildTriggerType {
@@ -22,6 +24,7 @@ impl fmt::Display for BuildTriggerType {
             BuildTriggerType::Retry => "retry",
             BuildTriggerType::Webhook => "webhook",
             BuildTriggerType::Schedule => "schedule",
+            BuildTriggerType::WebEdit => "webedit",
         };
         write!(f, "{}", s)
     }
@@ -144,6 +147,19 @@ pub struct SchedulePayload {
     pub cl_id: Option<i64>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WebEditPayload {
+    pub repo: String,
+    pub from_hash: String,
+    pub commit_hash: String,
+    pub cl_link: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cl_id: Option<i64>,
+    pub builds: serde_json::Value,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub triggered_by: Option<String>,
+}
+
 /// Trigger payload - stores context specific to each trigger type
 /// This enum is serialized to JSON and stored in database's trigger_payload column
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -154,6 +170,7 @@ pub enum BuildTriggerPayload {
     Retry(RetryPayload),
     Webhook(WebhookPayload),
     Schedule(SchedulePayload),
+    WebEdit(WebEditPayload),
 }
 
 impl BuildTriggerPayload {
@@ -164,6 +181,7 @@ impl BuildTriggerPayload {
             BuildTriggerPayload::Retry(p) => &p.repo,
             BuildTriggerPayload::Webhook(p) => &p.repo,
             BuildTriggerPayload::Schedule(p) => &p.repo,
+            BuildTriggerPayload::WebEdit(p) => &p.repo,
         }
     }
 
@@ -174,6 +192,7 @@ impl BuildTriggerPayload {
             BuildTriggerPayload::Retry(p) => &p.commit_hash,
             BuildTriggerPayload::Webhook(p) => &p.commit_hash,
             BuildTriggerPayload::Schedule(p) => &p.commit_hash,
+            BuildTriggerPayload::WebEdit(p) => &p.commit_hash,
         }
     }
 
@@ -184,6 +203,7 @@ impl BuildTriggerPayload {
             BuildTriggerPayload::Retry(p) => &p.cl_link,
             BuildTriggerPayload::Webhook(p) => &p.cl_link,
             BuildTriggerPayload::Schedule(p) => &p.cl_link,
+            BuildTriggerPayload::WebEdit(p) => &p.cl_link,
         }
     }
 
@@ -194,6 +214,7 @@ impl BuildTriggerPayload {
             BuildTriggerPayload::Retry(p) => p.cl_id,
             BuildTriggerPayload::Webhook(p) => p.cl_id,
             BuildTriggerPayload::Schedule(p) => p.cl_id,
+            BuildTriggerPayload::WebEdit(p) => p.cl_id,
         }
     }
 
@@ -204,6 +225,7 @@ impl BuildTriggerPayload {
             BuildTriggerPayload::Retry(p) => Some(&p.triggered_by),
             BuildTriggerPayload::Webhook(_) => None,
             BuildTriggerPayload::Schedule(_) => None,
+            BuildTriggerPayload::WebEdit(p) => p.triggered_by.as_deref(),
         }
     }
 
@@ -214,6 +236,7 @@ impl BuildTriggerPayload {
             BuildTriggerPayload::Retry(p) => &p.from_hash,
             BuildTriggerPayload::Webhook(_) => "",
             BuildTriggerPayload::Schedule(_) => "",
+            BuildTriggerPayload::WebEdit(p) => &p.from_hash,
         }
     }
 }
@@ -352,6 +375,25 @@ impl TriggerContext {
     }
 }
 
+impl From<mega_cl::Model> for TriggerContext {
+    fn from(cl: mega_cl::Model) -> Self {
+        TriggerContext {
+            trigger_type: BuildTriggerType::WebEdit,
+            trigger_source: TriggerSource::User,
+            triggered_by: Some(cl.username),
+            repo_path: cl.path,
+            from_hash: cl.from_hash,
+            commit_hash: cl.to_hash,
+            cl_link: Some(cl.link),
+            cl_id: Some(cl.id),
+            params: None,
+            original_trigger_id: None,
+            ref_name: None,
+            ref_type: None,
+        }
+    }
+}
+
 /// Create trigger request (new RESTful API)
 #[derive(Debug, Deserialize, ToSchema)]
 pub struct CreateTriggerRequest {