refactor: use TaskBuildRequest in bellatrix (#1942)

Signed-off-by: allure <1550220889@qq.com>

Author: AllureCurtain

ceres/src/build_trigger/changes_calculator.rs

@@ -3,13 +3,14 @@ use std::{
     sync::Arc,
 };
 
+pub use api_model::buck2::{status::Status, types::ProjectRelativePath};
 use common::errors::MegaError;
 use git_internal::hash::ObjectHash;
 use jupiter::storage::Storage;
 
 use crate::{
     api_service::{cache::GitObjectCache, mono_api_service::MonoApiService},
-    build_trigger::{SerializableBuildInfo, SerializableStatus, TriggerContext},
+    build_trigger::TriggerContext,
     model::change_list::{ClDiffFile, ClFilesRes},
 };
 
@@ -29,21 +30,21 @@ impl ChangesCalculator {
     pub async fn get_builds_for_commit(
         &self,
         context: &TriggerContext,
-    ) -> Result<Vec<SerializableBuildInfo>, MegaError> {
+    ) -> Result<Vec<Status<ProjectRelativePath>>, MegaError> {
         let old_files = self.get_commit_blobs(&context.from_hash).await?;
         let new_files = self.get_commit_blobs(&context.commit_hash).await?;
         let diff_files = self.cl_files_list(old_files, new_files).await?;
 
         let changes = self.build_changes(&context.repo_path, diff_files)?;
 
-        Ok(vec![SerializableBuildInfo { changes }])
+        Ok(changes)
     }
 
     fn build_changes(
         &self,
         cl_path: &str,
         cl_diff_files: Vec<ClDiffFile>,
-    ) -> Result<Vec<SerializableStatus>, MegaError> {
+    ) -> Result<Vec<Status<ProjectRelativePath>>, MegaError> {
         let cl_base = PathBuf::from(cl_path);
         let path_str = cl_base.to_str().ok_or_else(|| {
             MegaError::Other(format!("CL base path is not valid UTF-8: {:?}", cl_base))
@@ -73,11 +74,11 @@ impl ChangesCalculator {
                     .to_string();
 
                 let status = if s.action == "new" {
-                    SerializableStatus::Added(rel)
+                    Status::Added(ProjectRelativePath::new(&rel))
                 } else if s.action == "deleted" {
-                    SerializableStatus::Removed(rel)
+                    Status::Removed(ProjectRelativePath::new(&rel))
                 } else if s.action == "modified" {
-                    SerializableStatus::Modified(rel)
+                    Status::Modified(ProjectRelativePath::new(&rel))
                 } else {
                     return Err(MegaError::Other(format!(
                         "Unsupported change action: {}",

ceres/src/build_trigger/dispatcher.rs

@@ -1,13 +1,11 @@
 use std::sync::Arc;
 
-use bellatrix::{
-    Bellatrix,
-    orion_client::{BuildInfo, OrionBuildRequest},
-};
+use api_model::buck2::{api::TaskBuildRequest, status::Status, types::ProjectRelativePath};
+use bellatrix::Bellatrix;
 use common::errors::MegaError;
 use jupiter::storage::Storage;
 
-use crate::build_trigger::{BuildTrigger, BuildTriggerPayload, SerializableBuildInfo};
+use crate::build_trigger::{BuildTrigger, BuildTriggerPayload};
 
 /// Handles dispatching build triggers to the build execution layer (Bellatrix/Orion).
 pub struct BuildDispatcher {
@@ -39,24 +37,18 @@ impl BuildDispatcher {
                 BuildTriggerPayload::BuckFileUpload(p) => (&p.cl_link, &p.repo, &p.builds, p.cl_id),
             };
 
-            let builds: Vec<SerializableBuildInfo> = serde_json::from_value(builds_json.clone())
-                .map_err(|e| {
+            let changes: Vec<Status<ProjectRelativePath>> =
+                serde_json::from_value(builds_json.clone()).map_err(|e| {
                     tracing::error!("Failed to deserialize builds from payload: {}", e);
                     MegaError::Other(format!("Failed to deserialize builds from payload: {}", e))
                 })?;
 
-            let bellatrix_builds: Vec<BuildInfo> = builds
-                .into_iter()
-                .map(|info| BuildInfo {
-                    changes: info.changes.into_iter().map(|s| s.into()).collect(),
-                })
-                .collect();
-
-            let req = OrionBuildRequest {
+            let req = TaskBuildRequest {
+                repo: repo.to_string(),
                 cl_link: cl_link.to_string(),
-                mount_path: repo.to_string(),
-                cl: cl_id.unwrap_or(0),
-                builds: bellatrix_builds,
+                cl_id: cl_id.unwrap_or(0),
+                changes,
+                targets: None,
             };
 
             let task_id_str = self.bellatrix.on_post_receive(req).await.map_err(|e| {

ceres/src/build_trigger/model.rs

@@ -1,5 +1,6 @@
 use std::{collections::HashMap, fmt};
 
+pub use api_model::buck2::{status::Status, types::ProjectRelativePath};
 use callisto::mega_cl;
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
@@ -577,33 +578,3 @@ impl From<ListTriggersParams> for jupiter::storage::build_trigger_storage::ListT
         }
     }
 }
-
-#[derive(Clone, Serialize, Deserialize, Debug)]
-pub struct SerializableBuildInfo {
-    pub changes: Vec<SerializableStatus>,
-}
-
-#[derive(Clone, Serialize, Deserialize, Debug)]
-pub enum SerializableStatus {
-    Modified(String),
-    Added(String),
-    Removed(String),
-}
-
-impl From<SerializableStatus>
-    for bellatrix::orion_client::Status<bellatrix::orion_client::ProjectRelativePath>
-{
-    fn from(status: SerializableStatus) -> Self {
-        match status {
-            SerializableStatus::Modified(path) => bellatrix::orion_client::Status::Modified(
-                bellatrix::orion_client::ProjectRelativePath::new(&path),
-            ),
-            SerializableStatus::Added(path) => bellatrix::orion_client::Status::Added(
-                bellatrix::orion_client::ProjectRelativePath::new(&path),
-            ),
-            SerializableStatus::Removed(path) => bellatrix::orion_client::Status::Removed(
-                bellatrix::orion_client::ProjectRelativePath::new(&path),
-            ),
-        }
-    }
-}

orion-server/bellatrix/Cargo.toml

@@ -8,6 +8,7 @@ name = "bellatrix"
 path = "src/lib.rs"
 
 [dependencies]
+api-model = { workspace = true }
 common = { workspace = true }
 reqwest = { workspace = true, features = ["json"]}
 anyhow = { workspace = true }

orion-server/bellatrix/src/lib.rs

@@ -1,8 +1,9 @@
 pub mod orion_client;
 
+use api_model::buck2::api::TaskBuildRequest;
 use common::config::BuildConfig;
 
-use crate::orion_client::{OrionBuildRequest, OrionClient};
+use crate::orion_client::OrionClient;
 
 #[derive(Clone)]
 pub struct Bellatrix {
@@ -23,7 +24,7 @@ impl Bellatrix {
         self.build_config.enable_build
     }
 
-    pub async fn on_post_receive(&self, req: OrionBuildRequest) -> anyhow::Result<String> {
+    pub async fn on_post_receive(&self, req: TaskBuildRequest) -> anyhow::Result<String> {
         let task_id = self.orion.trigger_build(req).await?;
         Ok(task_id)
     }

orion-server/bellatrix/src/orion_client/mod.rs

@@ -1,52 +1,5 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize)]
-pub enum Status<Path: Clone> {
-    Modified(Path),
-    Added(Path),
-    Removed(Path),
-}
-
-#[derive(Clone, Debug, Hash, PartialEq, Eq, Deserialize, Serialize)]
-pub struct ProjectRelativePath(String);
-
-impl ProjectRelativePath {
-    pub fn new(path: &str) -> Self {
-        Self(path.to_owned())
-    }
-
-    pub fn from_abs(abs_path: &str, base: &str) -> Option<Self> {
-        let opt = abs_path
-            .strip_prefix(base)
-            .map(|s| s.trim_start_matches("/"));
-        opt.map(|s| Self(s.to_owned()))
-    }
-}
-
-impl<Path: Clone> Status<Path> {
-    pub fn path(&self) -> Path {
-        match self {
-            Self::Added(p) => p.clone(),
-            Self::Modified(p) => p.clone(),
-            Self::Removed(p) => p.clone(),
-        }
-    }
-}
-
-#[derive(Serialize, Debug)]
-pub struct BuildInfo {
-    pub changes: Vec<Status<ProjectRelativePath>>,
-}
-
-#[derive(Serialize, Debug)]
-pub struct OrionBuildRequest {
-    pub cl_link: String,
-    /// Monorepo mount path (Buck2 project root or subdirectory)
-    #[serde(rename = "mount_path", alias = "repo", alias = "path")]
-    pub mount_path: String,
-    pub cl: i64,
-    pub builds: Vec<BuildInfo>,
-}
+pub use api_model::buck2::{api::TaskBuildRequest, status::Status, types::ProjectRelativePath};
+use serde::Deserialize;
 
 /// Response from Orion task handler containing the assigned task ID.
 #[derive(Deserialize, Debug)]
@@ -69,7 +22,7 @@ impl OrionClient {
     }
 
     /// Trigger a build on Orion and return the assigned task ID.
-    pub async fn trigger_build(&self, req: OrionBuildRequest) -> anyhow::Result<String> {
+    pub async fn trigger_build(&self, req: TaskBuildRequest) -> anyhow::Result<String> {
         let url = format!("{}/task", self.base_url);
         tracing::info!("Try to trigger build with params:{:?}", req);
         let res = self.client.post(&url).json(&req).send().await?;