feat: allow a ci dedicated repo to run workflow

Author: Vo Hoang Long

Cargo.toml

@@ -54,9 +54,10 @@ chrono = "0.4"
 
 itertools = "0.13.0"
 
+derive_builder = "0.20.0"
+
 [dev-dependencies]
 insta = "1.26"
-derive_builder = "0.20.0"
 wiremock = "0.6.0"
 base64 = "0.22.1"
 tracing-test = "0.2.4"

src/bin/bors.rs

@@ -6,8 +6,9 @@ use std::time::Duration;
 
 use anyhow::Context;
 use bors::{
-    create_app, create_bors_process, create_github_client, load_repositories, BorsContext,
-    BorsGlobalEvent, CommandParser, PgDbClient, ServerState, TeamApiClient, WebhookSecret,
+    create_app, create_bors_process, create_github_client, create_github_client_from_access_token,
+    load_repositories, BorsContextBuilder, BorsGlobalEvent, CommandParser, PgDbClient, ServerState,
+    TeamApiClient, WebhookSecret,
 };
 use clap::Parser;
 use sqlx::postgres::PgConnectOptions;
@@ -18,6 +19,8 @@ use tracing_subscriber::filter::EnvFilter;
 /// How often should the bot check DB state, e.g. for handling timeouts.
 const PERIODIC_REFRESH: Duration = Duration::from_secs(120);
 
+const GITHUB_API_URL: &str = "https://api.github.com";
+
 #[derive(clap::Parser)]
 struct Opts {
     /// Github App ID.
@@ -39,6 +42,10 @@ struct Opts {
     /// Prefix used for bot commands in PR comments.
     #[arg(long, env = "CMD_PREFIX", default_value = "@bors")]
     cmd_prefix: String,
+
+    /// Prefix used for bot commands in PR comments.
+    #[arg(long, env = "CI_ACCESS_TOKEN")]
+    ci_access_token: Option<String>,
 }
 
 /// Starts a server that receives GitHub webhooks and generates events into a queue
@@ -81,15 +88,25 @@ fn try_main(opts: Opts) -> anyhow::Result<()> {
     let db = runtime
         .block_on(initialize_db(&opts.db))
         .context("Cannot initialize database")?;
-    let team_api = TeamApiClient::default();
-    let (client, loaded_repos) = runtime.block_on(async {
-        let client = create_github_client(
-            opts.app_id.into(),
-            "https://api.github.com".to_string(),
-            opts.private_key.into(),
-        )?;
-        let repos = load_repositories(&client, &team_api).await?;
-        Ok::<_, anyhow::Error>((client, repos))
+    let team_api_client = TeamApiClient::default();
+    let client = create_github_client(
+        opts.app_id.into(),
+        GITHUB_API_URL.to_string(),
+        opts.private_key.into(),
+    )?;
+    let ci_client = match opts.ci_access_token {
+        Some(access_token) => {
+            let client = create_github_client_from_access_token(
+                GITHUB_API_URL.to_string(),
+                access_token.into(),
+            )?;
+            Some(client)
+        }
+        None => None,
+    };
+    let loaded_repos = runtime.block_on(async {
+        let repos = load_repositories(&client, ci_client.clone(), &team_api_client).await?;
+        Ok::<_, anyhow::Error>(repos)
     })?;
 
     let mut repos = HashMap::default();
@@ -108,8 +125,17 @@ fn try_main(opts: Opts) -> anyhow::Result<()> {
         repos.insert(name, Arc::new(repo));
     }
 
-    let ctx = BorsContext::new(CommandParser::new(opts.cmd_prefix), Arc::new(db), repos);
-    let (repository_tx, global_tx, bors_process) = create_bors_process(ctx, client, team_api);
+    let ctx = BorsContextBuilder::default()
+        .parser(CommandParser::new(opts.cmd_prefix))
+        .db(Arc::new(db))
+        .repositories(repos)
+        .gh_client(client)
+        .ci_client(ci_client)
+        .team_api_client(team_api_client)
+        .build()
+        .unwrap();
+
+    let (repository_tx, global_tx, bors_process) = create_bors_process(ctx);
 
     let refresh_tx = global_tx.clone();
     let refresh_process = async move {

src/bors/command/parser.rs

@@ -22,6 +22,7 @@ enum CommandPart<'a> {
     KeyValue { key: &'a str, value: &'a str },
 }
 
+#[derive(Clone)]
 pub struct CommandParser {
     prefix: String,
 }

src/bors/context.rs

@@ -3,27 +3,24 @@ use std::{
     sync::{Arc, RwLock},
 };
 
-use crate::{bors::command::CommandParser, github::GithubRepoName, PgDbClient};
+use derive_builder::Builder;
+use octocrab::Octocrab;
+
+use crate::{bors::command::CommandParser, github::GithubRepoName, PgDbClient, TeamApiClient};
 
 use super::RepositoryState;
 
+#[derive(Builder)]
 pub struct BorsContext {
     pub parser: CommandParser,
     pub db: Arc<PgDbClient>,
+    #[builder(field(
+        ty = "HashMap<GithubRepoName, Arc<RepositoryState>>",
+        build = "RwLock::new(self.repositories.clone())"
+    ))]
     pub repositories: RwLock<HashMap<GithubRepoName, Arc<RepositoryState>>>,
-}
-
-impl BorsContext {
-    pub fn new(
-        parser: CommandParser,
-        db: Arc<PgDbClient>,
-        repositories: HashMap<GithubRepoName, Arc<RepositoryState>>,
-    ) -> Self {
-        let repositories = RwLock::new(repositories);
-        Self {
-            parser,
-            db,
-            repositories,
-        }
-    }
+    pub gh_client: Octocrab,
+    #[builder(default)]
+    pub ci_client: Option<Octocrab>,
+    pub team_api_client: TeamApiClient,
 }

src/bors/handlers/mod.rs

@@ -1,7 +1,6 @@
 use std::sync::Arc;
 
 use anyhow::Context;
-use octocrab::Octocrab;
 use tracing::Instrument;
 
 use crate::bors::command::{BorsCommand, CommandParseError};
@@ -17,7 +16,7 @@ use crate::bors::handlers::workflow::{
     handle_check_suite_completed, handle_workflow_completed, handle_workflow_started,
 };
 use crate::bors::{BorsContext, Comment, RepositoryState};
-use crate::{load_repositories, PgDbClient, TeamApiClient};
+use crate::{load_repositories, PgDbClient};
 
 #[cfg(test)]
 use crate::tests::util::TestSyncMarker;
@@ -142,16 +141,12 @@ pub static WAIT_FOR_REFRESH: TestSyncMarker = TestSyncMarker::new();
 pub async fn handle_bors_global_event(
     event: BorsGlobalEvent,
     ctx: Arc<BorsContext>,
-    gh_client: &Octocrab,
-    team_api_client: &TeamApiClient,
 ) -> anyhow::Result<()> {
     let db = Arc::clone(&ctx.db);
     match event {
         BorsGlobalEvent::InstallationsChanged => {
             let span = tracing::info_span!("Installations changed");
-            reload_repos(ctx, gh_client, team_api_client)
-                .instrument(span)
-                .await?;
+            reload_repos(ctx).instrument(span).await?;
         }
         BorsGlobalEvent::Refresh => {
             let span = tracing::info_span!("Refresh");
@@ -161,7 +156,7 @@ pub async fn handle_bors_global_event(
                 let repo = Arc::clone(&repo);
                 async {
                     let subspan = tracing::info_span!("Repo", repo = repo.repository().to_string());
-                    refresh_repository(repo, Arc::clone(&db), team_api_client)
+                    refresh_repository(repo, Arc::clone(&db), &ctx.team_api_client)
                         .instrument(subspan)
                         .await
                 }
@@ -274,12 +269,9 @@ async fn handle_comment(
     Ok(())
 }
 
-async fn reload_repos(
-    ctx: Arc<BorsContext>,
-    gh_client: &Octocrab,
-    team_api_client: &TeamApiClient,
-) -> anyhow::Result<()> {
-    let reloaded_repos = load_repositories(gh_client, team_api_client).await?;
+async fn reload_repos(ctx: Arc<BorsContext>) -> anyhow::Result<()> {
+    let reloaded_repos =
+        load_repositories(&ctx.gh_client, ctx.ci_client.clone(), &ctx.team_api_client).await?;
     let mut repositories = ctx.repositories.write().unwrap();
     for repo in repositories.values() {
         if !reloaded_repos.contains_key(repo.repository()) {

src/bors/handlers/trybuild.rs

@@ -10,6 +10,7 @@ use crate::bors::Comment;
 use crate::bors::RepositoryState;
 use crate::database::RunId;
 use crate::database::{BuildModel, BuildStatus, PullRequestModel, WorkflowStatus, WorkflowType};
+use crate::github::api::client::GithubRepositoryClient;
 use crate::github::GithubRepoName;
 use crate::github::{
     CommitSha, GithubUser, LabelTrigger, MergeError, PullRequest, PullRequestNumber,
@@ -62,66 +63,94 @@ pub(super) async fn command_try_build(
         }
     };
 
+    match attempt_merge(
+        &repo.ci_client,
+        &pr.head.sha,
+        &base_sha,
+        &auto_merge_commit_message(pr, repo.client.repository(), "<try>", jobs),
+    )
+    .await?
+    {
+        MergeResult::Success(merge_sha) => {
+            // If the merge was succesful, run CI with merged commit
+            run_try_build(&repo.ci_client, &db, pr_model, merge_sha.clone(), base_sha).await?;
+
+            handle_label_trigger(repo, pr.number, LabelTrigger::TryBuildStarted).await?;
+
+            repo.client
+                .post_comment(pr.number, trying_build_comment(&pr.head.sha, &merge_sha))
+                .await
+        }
+        MergeResult::Conflict => {
+            repo.client
+                .post_comment(pr.number, merge_conflict_comment(&pr.head.name))
+                .await
+        }
+    }
+}
+
+async fn attempt_merge(
+    ci_client: &GithubRepositoryClient,
+    head_sha: &CommitSha,
+    base_sha: &CommitSha,
+    merge_message: &str,
+) -> anyhow::Result<MergeResult> {
     tracing::debug!("Attempting to merge with base SHA {base_sha}");
 
     // First set the try branch to our base commit (either the selected parent or the main branch).
-    repo.client
-        .set_branch_to_sha(TRY_MERGE_BRANCH_NAME, &base_sha)
+    ci_client
+        .set_branch_to_sha(TRY_MERGE_BRANCH_NAME, base_sha)
         .await
         .map_err(|error| anyhow!("Cannot set try merge branch to {}: {error:?}", base_sha.0))?;
 
     // Then merge the PR commit into the try branch
-    match repo
-        .client
-        .merge_branches(
-            TRY_MERGE_BRANCH_NAME,
-            &pr.head.sha,
-            &auto_merge_commit_message(pr, repo.client.repository(), "<try>", jobs),
-        )
+    match ci_client
+        .merge_branches(TRY_MERGE_BRANCH_NAME, head_sha, merge_message)
         .await
     {
         Ok(merge_sha) => {
             tracing::debug!("Merge successful, SHA: {merge_sha}");
-            // If the merge was succesful, then set the actual try branch that will run CI to the
-            // merged commit.
-            repo.client
-                .set_branch_to_sha(TRY_BRANCH_NAME, &merge_sha)
-                .await
-                .map_err(|error| anyhow!("Cannot set try branch to main branch: {error:?}"))?;
-
-            db.attach_try_build(
-                pr_model,
-                TRY_BRANCH_NAME.to_string(),
-                merge_sha.clone(),
-                base_sha.clone(),
-            )
-            .await?;
-            tracing::info!("Try build started");
-
-            handle_label_trigger(repo, pr.number, LabelTrigger::TryBuildStarted).await?;
 
-            let comment = Comment::new(format!(
-                ":hourglass: Trying commit {} with merge {}…",
-                pr.head.sha.clone(),
-                merge_sha
-            ));
-            repo.client.post_comment(pr.number, comment).await?;
-            Ok(())
+            Ok(MergeResult::Success(merge_sha))
         }
         Err(MergeError::Conflict) => {
             tracing::warn!("Merge conflict");
-            repo.client
-                .post_comment(
-                    pr.number,
-                    Comment::new(merge_conflict_message(&pr.head.name)),
-                )
-                .await?;
-            Ok(())
+
+            Ok(MergeResult::Conflict)
         }
         Err(error) => Err(error.into()),
     }
 }
 
+async fn run_try_build(
+    ci_client: &GithubRepositoryClient,
+    db: &PgDbClient,
+    pr_model: PullRequestModel,
+    commit_sha: CommitSha,
+    parent_sha: CommitSha,
+) -> anyhow::Result<()> {
+    ci_client
+        .set_branch_to_sha(TRY_BRANCH_NAME, &commit_sha)
+        .await
+        .map_err(|error| anyhow!("Cannot set try branch to main branch: {error:?}"))?;
+
+    db.attach_try_build(
+        pr_model,
+        TRY_BRANCH_NAME.to_string(),
+        commit_sha,
+        parent_sha,
+    )
+    .await?;
+
+    tracing::info!("Try build started");
+    Ok(())
+}
+
+enum MergeResult {
+    Success(CommitSha),
+    Conflict,
+}
+
 fn get_base_sha(
     pr_model: &PullRequestModel,
     parent: Option<Parent>,
@@ -267,8 +296,14 @@ fn auto_merge_commit_message(
     message
 }
 
-fn merge_conflict_message(branch: &str) -> String {
-    format!(
+fn trying_build_comment(head_sha: &CommitSha, merge_sha: &CommitSha) -> Comment {
+    Comment::new(format!(
+        ":hourglass: Trying commit {head_sha} with merge {merge_sha}…"
+    ))
+}
+
+fn merge_conflict_comment(branch: &str) -> Comment {
+    let message = format!(
         r#":lock: Merge conflict
 
 This pull request and the master branch diverged in a way that cannot
@@ -298,7 +333,8 @@ handled during merge and rebase. This is normal, and you should still perform st
 
 </details>
 "#
-    )
+    );
+    Comment::new(message)
 }
 
 async fn check_try_permissions(