Add workflow links to try build started comments

Author: mostafa630

src/bors/comment.rs

@@ -198,6 +198,14 @@ pub fn try_build_started_comment(
     Comment::new(msg)
 }
 
+pub fn append_workflow_links_to_comment(comment_content: &mut String, workflow_links: Vec<String>) {
+    comment_content.push_str("\n\n**Workflows**:\n\n");
+
+    for link in workflow_links {
+        comment_content.push_str(&format!("- {link}\n"));
+    }
+}
+
 pub fn merge_conflict_comment(branch: &str) -> Comment {
     let message = format!(
         r#":lock: Merge conflict

src/bors/handlers/mod.rs

@@ -108,7 +108,7 @@ pub async fn handle_bors_repository_event(
                 repo = payload.repository.to_string(),
                 id = payload.run_id.into_inner()
             );
-            handle_workflow_started(db, payload)
+            handle_workflow_started(repo, db, payload)
                 .instrument(span.clone())
                 .await?;
 

src/bors/handlers/workflow.rs

@@ -1,5 +1,8 @@
+use super::trybuild::TRY_BRANCH_NAME;
 use crate::PgDbClient;
-use crate::bors::comment::{build_failed_comment, try_build_succeeded_comment};
+use crate::bors::comment::{
+    CommentTag, append_workflow_links_to_comment, build_failed_comment, try_build_succeeded_comment,
+};
 use crate::bors::event::{WorkflowRunCompleted, WorkflowRunStarted};
 use crate::bors::handlers::labels::handle_label_trigger;
 use crate::bors::handlers::{BuildType, is_bors_observed_branch};
@@ -17,6 +20,7 @@ use std::sync::Arc;
 use std::time::Duration;
 
 pub(super) async fn handle_workflow_started(
+    repo: Arc<RepositoryState>,
     db: Arc<PgDbClient>,
     payload: WorkflowRunStarted,
 ) -> anyhow::Result<()> {
@@ -53,14 +57,53 @@ pub(super) async fn handle_workflow_started(
     tracing::info!("Storing workflow started into DB");
     db.create_workflow(
         &build,
-        payload.name,
-        payload.url,
+        payload.name.clone(),
+        payload.url.clone(),
         payload.run_id.into(),
-        payload.workflow_type,
+        payload.workflow_type.clone(),
         WorkflowStatus::Pending,
     )
     .await?;
 
+    if build.branch == TRY_BRANCH_NAME {
+        add_workflow_links_to_try_build_start_comment(repo, db, &build, payload).await?;
+    }
+
+    Ok(())
+}
+
+async fn add_workflow_links_to_try_build_start_comment(
+    repo: Arc<RepositoryState>,
+    db: Arc<PgDbClient>,
+    build: &BuildModel,
+    payload: WorkflowRunStarted,
+) -> anyhow::Result<()> {
+    let Some(pr) = db.find_pr_by_build(&build).await? else {
+        tracing::warn!("PR for build not found");
+        return Ok(());
+    };
+    let comments = db
+        .get_tagged_bot_comments(&payload.repository, pr.number, CommentTag::TryBuildStarted)
+        .await?;
+
+    let Some(try_build_comment) = comments.last() else {
+        tracing::warn!("No try build comment found for PR");
+        return Ok(());
+    };
+
+    let workflows = db.get_workflow_urls_for_build(&build).await?;
+
+    let mut comment_content = repo
+        .client
+        .get_comment_content(&try_build_comment.node_id)
+        .await?;
+
+    append_workflow_links_to_comment(&mut comment_content, workflows);
+
+    repo.client
+        .update_comment_content(&try_build_comment.node_id, &comment_content)
+        .await?;
+
     Ok(())
 }
 
@@ -108,7 +151,6 @@ pub(super) async fn handle_workflow_completed(
     )
     .await
 }
-
 /// Attempt to complete a pending build after a workflow run has been completed.
 /// We assume that the status of the completed workflow run has already been updated in the
 /// database.

src/database/mod.rs

@@ -394,7 +394,7 @@ impl PullRequestModel {
 
 /// Describes whether a workflow is a Github Actions workflow or if it's a job from some external
 /// CI.
-#[derive(Debug, PartialEq, sqlx::Type)]
+#[derive(Debug, Clone, PartialEq, sqlx::Type)]
 #[sqlx(type_name = "TEXT")]
 #[sqlx(rename_all = "lowercase")]
 pub enum WorkflowType {

src/database/operations.rs

@@ -1043,6 +1043,7 @@ pub(crate) async fn get_tagged_bot_comments(
             WHERE repository = $1
               AND pr_number = $2
               AND tag = $3
+            ORDER BY created_at
             "#,
             repo as &GithubRepoName,
             pr_number.0 as i32,

src/github/api/client.rs

@@ -498,6 +498,109 @@ impl GithubRepositoryClient {
         .await?;
         Ok(())
     }
+
+    pub async fn get_comment_content(&self, node_id: &str) -> anyhow::Result<String> {
+        const QUERY: &str = r#"
+            query($node_id: ID!) {
+                node(id: $node_id) {
+                    ... on IssueComment {
+                        body
+                    }
+                }
+            }
+        "#;
+
+        #[derive(Serialize)]
+        struct Variables<'a> {
+            node_id: &'a str,
+        }
+
+        #[derive(Deserialize)]
+        struct Output {
+            node: Option<IssueCommentNode>,
+        }
+
+        #[derive(Deserialize)]
+        struct IssueCommentNode {
+            body: String,
+        }
+
+        tracing::debug!(node_id, "Fetching comment content");
+
+        let output: Output =
+            perform_retryable("get_comment_content", RetryMethod::default(), || async {
+                self.graphql::<Output, Variables>(QUERY, Variables { node_id })
+                    .await
+                    .context("Failed to fetch comment content")
+            })
+            .await?;
+
+        match output.node {
+            Some(comment) => Ok(comment.body),
+            None => anyhow::bail!("No comment found for node_id: {}", node_id),
+        }
+    }
+    pub async fn update_comment_content(
+        &self,
+        node_id: &str,
+        new_body: &str,
+    ) -> anyhow::Result<()> {
+        const QUERY: &str = r#"
+            mutation($id: ID!, $body: String!) {
+                updateComment(input: {id: $id, body: $body}) {
+                    comment {
+                        id
+                        body
+                    }
+                }
+            }
+        "#;
+
+        #[derive(Serialize)]
+        struct Variables<'a> {
+            id: &'a str,
+            body: &'a str,
+        }
+
+        #[derive(Deserialize)]
+        struct Output {
+            update_comment: Option<UpdatedComment>,
+        }
+
+        #[derive(Deserialize)]
+        struct UpdatedComment {
+            comment: CommentNode,
+        }
+
+        #[derive(Deserialize)]
+        struct CommentNode {
+            body: String,
+        }
+
+        tracing::debug!(node_id, "Updating comment content");
+
+        let output: Output =
+            perform_retryable("update_comment_content", RetryMethod::default(), || async {
+                self.graphql::<Output, Variables>(
+                    QUERY,
+                    Variables {
+                        id: node_id,
+                        body: new_body,
+                    },
+                )
+                .await
+                .context("Failed to update comment")
+            })
+            .await?;
+
+        match output.update_comment {
+            Some(updated_comment) => {
+                tracing::debug!("Updated comment content: {}", updated_comment.comment.body);
+                Ok(())
+            }
+            None => anyhow::bail!("Failed to update comment: {node_id}"),
+        }
+    }
 }
 
 /// The reasons a piece of content can be reported or hidden.

src/tests/mocks/github.rs

@@ -108,40 +108,79 @@ async fn mock_graphql(github: Arc<tokio::sync::Mutex<GitHubState>>, mock_server:
             let query: Document<&str> =
                 graphql_parser::parse_query(&body.query).expect("Could not parse GraphQL query");
             let definition = query.definitions.into_iter().next().unwrap();
-            let mutation = match definition {
-                Definition::Operation(OperationDefinition::Mutation(mutation)) => mutation,
+            let selection_set = match definition {
+                Definition::Operation(OperationDefinition::Mutation(mutation)) => {
+                    mutation.selection_set
+                }
+                Definition::Operation(OperationDefinition::Query(query)) => query.selection_set,
                 _ => panic!("Unexpected GraphQL query: {}", body.query),
             };
-            let selection = mutation.selection_set.items.into_iter().next().unwrap();
+            let selection = selection_set.items.into_iter().next().unwrap();
             let operation = match selection {
                 Selection::Field(field) => field,
                 _ => panic!("Unexpected GraphQL selection"),
             };
-            if operation.name == "minimizeComment" {
-                #[derive(serde::Deserialize)]
-                struct Variables {
-                    node_id: String,
-                    reason: HideCommentReason,
+
+            match operation.name {
+                "minimizeComment" => {
+                    #[derive(serde::Deserialize)]
+                    struct Variables {
+                        node_id: String,
+                        reason: HideCommentReason,
+                    }
+
+                    let github = github.clone();
+                    let data: Variables = serde_json::from_value(body.variables).unwrap();
+
+                    // We have to use e.g. `blocking_lock` to lock from a sync function.
+                    // It has to happen in a separate thread though.
+                    std::thread::spawn(move || {
+                        github.blocking_lock().add_hidden_comment(HiddenComment {
+                            node_id: data.node_id,
+                            reason: data.reason,
+                        });
+                    })
+                    .join()
+                    .unwrap();
+                    ResponseTemplate::new(200).set_body_json(HashMap::<String, String>::new())
+                }
+                "updateComment" => {
+                    #[derive(serde::Deserialize)]
+                    struct Variables {
+                        id: String,
+                        body: String,
+                    }
+
+                    let data: Variables = serde_json::from_value(body.variables).unwrap();
+                    let response = serde_json::json!({
+                        "update_comment": {
+                            "comment": {
+                                "id": data.id,
+                                "body": data.body
+                            }
+                        }
+                    });
+
+                    ResponseTemplate::new(200).set_body_json(response)
                 }
+                "node" => {
+                    #[derive(serde::Deserialize)]
+                    struct Variables {
+                        node_id: String,
+                    }
 
-                let github = github.clone();
-                let data: Variables = serde_json::from_value(body.variables).unwrap();
+                    let data: Variables = serde_json::from_value(body.variables).unwrap();
 
-                // We have to use e.g. `blocking_lock` to lock from a sync function.
-                // It has to happen in a separate thread though.
-                std::thread::spawn(move || {
-                    github.blocking_lock().add_hidden_comment(HiddenComment {
-                        node_id: data.node_id,
-                        reason: data.reason,
+                    let response = serde_json::json!({
+                        "node": {
+                                "__typename": "IssueComment",
+                                "body":format!(":hourglass: Trying commit {} \n To cancel the try build, run the command @bors try cancel`.", data.node_id)
+                        }
                     });
-                })
-                .join()
-                .unwrap();
-            } else {
-                panic!("Unexpected operation {}", operation.name);
+                    ResponseTemplate::new(200).set_body_json(response)
+                }
+                _ => panic!("Unexpected GraphQL operation {}", operation.name),
             }
-
-            ResponseTemplate::new(200).set_body_json(HashMap::<String, String>::new())
         },
         "POST",
         "^/graphql$".to_string(),