[orion] Replace worker-server commun with WS msg

Signed-off-by: AidCheng <cn.aiden.cheng@gmail.com>

Author: AidCheng

jupiter/callisto/src/mega_code_review_thread.rs

@@ -3,7 +3,7 @@
 use sea_orm::entity::prelude::*;
 use serde::{Deserialize, Serialize};
 
-use super::sea_orm_active_enums::{DiffSideEnum, ThreadStatusEnum};
+use super::sea_orm_active_enums::{ThreadStatusEnum};
 
 #[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
 #[sea_orm(table_name = "mega_code_review_thread")]

orion-server/src/api.rs

@@ -1717,7 +1717,7 @@ async fn immediate_work(
     );
     let build_info = BuildInfo {
         event_payload: event,
-        target_id: target.id.to_string(),
+        target_id: target.id,
         target_path: target.target_path.clone(),
         changes: req.build.changes.clone(),
         _worker_id: chosen_id.clone(),
@@ -1726,12 +1726,13 @@ async fn immediate_work(
     };
 
     // Send build to worker
-    let msg = TaskBuildRequest {
+    let msg = WSMessage::Task {
         id: build.id.to_string(),
         repo: build.repo.to_string(),
         changes: req.build.changes.clone(),
         cl_link: req.cl_link.to_string(),
     };
+
     if let Some(mut worker) = state.scheduler.workers.get_mut(&chosen_id)
         && worker.sender.send(msg).is_ok()
     {

orion-server/src/scheduler.rs

@@ -270,6 +270,9 @@ impl TaskScheduler {
         }
     }
 
+    /// Ensure target exists for the given task and target path, return the target model
+    ///
+    /// Creates a new target if not exists
     pub async fn ensure_target(
         &self,
         task_id: Uuid,
@@ -330,7 +333,7 @@ impl TaskScheduler {
 
         let pending_build_event = PendingBuildEvent {
             event_payload: event,
-            target_id: None,
+            target_id: target_model.id.into(),
             target_path: None,
             changes: changes,
             created_at: Instant::now(),
@@ -456,7 +459,7 @@ impl TaskScheduler {
             id: Set(pending_build_event.build_event_id),
             task_id: Set(pending_build_event.task_id),
             // target_id: Set(pending_build_event.target_id),
-            target_id: Set(None),
+            target_id: Set(Uuid::nil()),
             exit_code: Set(None),
             start_at: Set(start_at_tz),
             end_at: Set(None),
@@ -503,8 +506,7 @@ impl TaskScheduler {
                 if let Err(e) = targets::update_state(
                     &self.conn,
                     //TODO: update target_id here
-                    // pending_task.target_id,
-                    0,
+                    pending_build_event.target_id.unwrap_or_else(|| Uuid::nil()),
                     TargetState::Building,
                     Some(start_at_tz),
                     None,
@@ -533,7 +535,7 @@ impl TaskScheduler {
                 let _ = targets::update_state(
                     &self.conn,
                     // TODO: update target_id here
-                    pending_build_event.target_id,
+                    pending_build_event.target_id.unwrap_or_else(|| Uuid::nil()),
                     TargetState::Pending,
                     Some(start_at_tz),
                     None,

orion/buck/types.rs

@@ -15,7 +15,6 @@ use std::{ffi::OsStr, fmt, hash::Hash, str::FromStr};
 use parse_display::Display;
 use serde::{Deserialize, Serialize};
 use td_util::string::InternString;
-use utoipa::ToSchema;
 
 use crate::{cells::CellInfo, labels::Labels};
 

orion/src/api.rs

@@ -1,6 +1,5 @@
 use api_model::buck2::{
-    api::{TaskBuildRequest, TaskBuildResult},
-    ws::WSMessage,
+    api::TaskBuildResult, status::Status, types::ProjectRelativePath, ws::WSMessage,
 };
 use tokio::sync::mpsc::UnboundedSender;
 use uuid::Uuid;
@@ -46,7 +45,9 @@ use crate::buck_controller;
 /// Immediate acknowledgment that the build task has been queued and started
 pub async fn buck_build(
     id: Uuid,
-    req: TaskBuildRequest,
+    cl_link: String,
+    repo: String,
+    changes: Vec<Status<ProjectRelativePath>>,
     sender: UnboundedSender<WSMessage>,
 ) -> TaskBuildResult {
     let id_str = id.to_string();
@@ -55,48 +56,43 @@ pub async fn buck_build(
     // Spawn background task to handle the actual build process
     tokio::spawn(async move {
         // Execute the build operation via buck_controller
-        let build_result = match buck_controller::build(
-            id_str.clone(),
-            req.repo,
-            req.cl_link,
-            sender.clone(),
-            req.changes,
-        )
-        .await
-        {
-            Ok(status) => {
-                let message = format!(
-                    "Build {}",
-                    if status.success() {
-                        "succeeded"
-                    } else {
-                        "failed"
+        let build_result =
+            match buck_controller::build(id_str.clone(), repo, cl_link, sender.clone(), changes)
+                .await
+            {
+                Ok(status) => {
+                    let message = format!(
+                        "Build {}",
+                        if status.success() {
+                            "succeeded"
+                        } else {
+                            "failed"
+                        }
+                    );
+                    tracing::info!(
+                        "[Task {}] {}; Exit code: {:?}",
+                        id_str,
+                        message,
+                        status.code()
+                    );
+                    TaskBuildResult {
+                        success: status.success(),
+                        id: id_str.clone(),
+                        exit_code: status.code(),
+                        message,
                     }
-                );
-                tracing::info!(
-                    "[Task {}] {}; Exit code: {:?}",
-                    id_str,
-                    message,
-                    status.code()
-                );
-                TaskBuildResult {
-                    success: status.success(),
-                    id: id_str.clone(),
-                    exit_code: status.code(),
-                    message,
                 }
-            }
-            Err(e) => {
-                let error_msg = format!("Build execution failed: {e}");
-                tracing::error!("[Task {}] {}", id_str, error_msg);
-                TaskBuildResult {
-                    success: false,
-                    id: id_str.clone(),
-                    exit_code: None,
-                    message: error_msg,
+                Err(e) => {
+                    let error_msg = format!("Build execution failed: {e}");
+                    tracing::error!("[Task {}] {}", id_str, error_msg);
+                    TaskBuildResult {
+                        success: false,
+                        id: id_str.clone(),
+                        exit_code: None,
+                        message: error_msg,
+                    }
                 }
-            }
-        };
+            };
 
         // Send build completion notification via WebSocket
         let complete_msg = WSMessage::TaskBuildComplete {

orion/src/buck_controller.rs

@@ -8,7 +8,8 @@ use std::{
 
 use anyhow::anyhow;
 use api_model::buck2::{
-    types::{ProjectRelativePath, Status, TaskPhase},
+    status::Status,
+    types::{ProjectRelativePath, TaskPhase},
     ws::WSMessage,
 };
 use once_cell::sync::Lazy;

orion/src/ws.rs

@@ -1,6 +1,6 @@
 use std::{ops::ControlFlow, time::Duration};
 
-use api_model::buck2::{api::TaskBuildRequest, ws::WSMessage};
+use api_model::buck2::ws::WSMessage;
 use futures_util::{SinkExt, StreamExt};
 use tokio::{
     net::TcpStream,
@@ -188,12 +188,9 @@ async fn process_server_message(
 
                                 let build_result = buck_build(
                                     task_id_uuid,
-                                    TaskBuildRequest {
-                                        repo,
-                                        cl_link,
-                                        changes,
-                                        None,
-                                    },
+                                    repo,
+                                    cl_link,
+                                    changes,
                                     sender.clone(),
                                 )
                                 .await;