Merge pull request #529 from Kobzol/pause-resume

Implement pause/resume functionality

Author: Kobzol

src/bors/command/mod.rs

@@ -132,4 +132,9 @@ pub enum BorsCommand {
     /// Clear a failed auto build status from an approved PR.
     /// This will cause the merge queue to attempt to start a new auto build and retry merging the PR again.
     Retry,
+    /// Pause the merge queue and related functionality ([un]approving, delegation, tree closing,
+    /// etc.).
+    Pause,
+    /// Resume the merge queue and related functionality.
+    Resume,
 }

src/bors/command/parser.rs

@@ -144,6 +144,8 @@ const DEFAULT_PARSERS: &[ParserFn] = &[
     parser_ping,
     parser_retry,
     parser_tree_ops,
+    parser_pause,
+    parser_resume,
 ];
 
 const ONLY_TRY_PARSERS: &[ParserFn] = &[parser_try_cancel, parser_try];
@@ -441,6 +443,22 @@ fn parser_tree_ops(command: &CommandPart<'_>, _parts: &[CommandPart<'_>]) -> Par
     }
 }
 
+/// Parses `@bors pause` command.
+fn parser_pause(command: &CommandPart<'_>, _parts: &[CommandPart<'_>]) -> ParseResult {
+    match command {
+        CommandPart::Bare("pause") => Some(Ok(BorsCommand::Pause)),
+        _ => None,
+    }
+}
+
+/// Parses `@bors resume` command.
+fn parser_resume(command: &CommandPart<'_>, _parts: &[CommandPart<'_>]) -> ParseResult {
+    match command {
+        CommandPart::Bare("resume") => Some(Ok(BorsCommand::Resume)),
+        _ => None,
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::bors::command::parser::{CommandParseError, CommandParser};

src/bors/handlers/mod.rs

@@ -507,6 +507,16 @@ async fn handle_comment(
                             .instrument(span)
                             .await
                     }
+                    BorsCommand::Pause => {
+                        tracing::info!("Pausing {}", repo.repository());
+                        repo.set_paused(true);
+                        Ok(())
+                    }
+                    BorsCommand::Resume => {
+                        tracing::info!("Resuming {}", repo.repository());
+                        repo.set_paused(false);
+                        Ok(())
+                    }
                 };
                 if result.is_err() {
                     return result.context("Cannot execute Bors command");

src/bors/handlers/ping.rs

@@ -8,8 +8,12 @@ pub(super) async fn command_ping(
     repo: Arc<RepositoryState>,
     pr_number: PullRequestNumber,
 ) -> anyhow::Result<()> {
+    let mut msg = "Pong 🏓!".to_string();
+    if repo.is_paused() {
+        msg.push_str(" (bors is paused)");
+    }
     repo.client
-        .post_comment(pr_number, Comment::new("Pong 🏓!".to_string()))
+        .post_comment(pr_number, Comment::new(msg))
         .await?;
     Ok(())
 }

src/bors/handlers/retry.rs

@@ -25,7 +25,7 @@ pub(super) async fn command_retry(
     if matches!(pr_model.queue_status(), QueueStatus::Failed(_, _)) {
         db.clear_auto_build(pr_model).await?;
         merge_queue_tx.notify().await?;
-    } else {
+    } else if !repo_state.is_paused() {
         notify_of_invalid_retry_state(&repo_state, pr.number()).await?;
     }
 

src/bors/handlers/review.rs

@@ -63,15 +63,19 @@ pub(super) async fn command_approve(
     let priority = priority.or(pr.db.priority.map(|p| p as u32));
 
     merge_queue_tx.notify().await?;
-    handle_label_trigger(
-        &repo_state,
-        pr.number(),
-        Some(pr.github),
-        LabelTrigger::Approved,
-    )
-    .await?;
 
-    notify_of_approval(ctx, &repo_state, pr, priority, approver.as_str()).await
+    if !repo_state.is_paused() {
+        handle_label_trigger(
+            &repo_state,
+            pr.number(),
+            Some(pr.github),
+            LabelTrigger::Approved,
+        )
+        .await?;
+
+        notify_of_approval(ctx, &repo_state, pr, priority, approver.as_str()).await?;
+    }
+    Ok(())
 }
 
 /// Keywords that will prevent an approval if they appear in the PR's title.
@@ -152,7 +156,10 @@ pub(super) async fn command_unapprove(
     )
     .await?;
     unapprove_pr(&repo_state, &db, pr.db, pr.github).await?;
-    notify_of_unapproval(&repo_state, pr, auto_build_cancel_message).await?;
+
+    if !repo_state.is_paused() {
+        notify_of_unapproval(&repo_state, pr, auto_build_cancel_message).await?;
+    }
 
     Ok(())
 }
@@ -193,15 +200,19 @@ pub(super) async fn command_delegate(
     }
 
     db.delegate(pr.db, delegated_permission).await?;
-    notify_of_delegation(
-        &repo_state,
-        pr.number(),
-        &pr.github.author.username,
-        &author.username,
-        delegated_permission,
-        bot_prefix,
-    )
-    .await
+
+    if !repo_state.is_paused() {
+        notify_of_delegation(
+            &repo_state,
+            pr.number(),
+            &pr.github.author.username,
+            &author.username,
+            delegated_permission,
+            bot_prefix,
+        )
+        .await?;
+    }
+    Ok(())
 }
 
 /// Revoke any previously granted delegation.
@@ -258,7 +269,11 @@ pub(super) async fn command_close_tree(
     .await?;
 
     merge_queue_tx.notify().await?;
-    notify_of_tree_closed(&repo_state, pr.number(), priority).await
+
+    if !repo_state.is_paused() {
+        notify_of_tree_closed(&repo_state, pr.number(), priority).await?;
+    }
+    Ok(())
 }
 
 pub(super) async fn command_open_tree(
@@ -277,7 +292,11 @@ pub(super) async fn command_open_tree(
         .await?;
 
     merge_queue_tx.notify().await?;
-    notify_of_tree_open(&repo_state, pr.number()).await
+
+    if !repo_state.is_paused() {
+        notify_of_tree_open(&repo_state, pr.number()).await?;
+    }
+    Ok(())
 }
 
 fn sufficient_approve_permission(repo: Arc<RepositoryState>, author: &GithubUser) -> bool {
@@ -1399,4 +1418,25 @@ labels_blocking_approval = ["proposed-final-comment-period", "final-comment-peri
         })
         .await;
     }
+
+    #[sqlx::test]
+    async fn pause_resume(pool: sqlx::PgPool) {
+        run_test(pool, async |ctx: &mut BorsTester| {
+            ctx.post_comment("@bors pause").await?;
+            ctx.post_comment("@bors r+").await?;
+            ctx.wait_for_pr((), |pr| pr.is_approved()).await?;
+            ctx.run_merge_queue_now().await;
+            ctx.pr(()).await.expect_no_auto_build();
+            ctx.post_comment("@bors resume").await?;
+
+            // Sync
+            ctx.post_comment("@bors info").await?;
+            ctx.expect_comments((), 1).await;
+
+            ctx.start_and_finish_auto_build(()).await?;
+
+            Ok(())
+        })
+        .await;
+    }
 }

src/bors/merge_queue.rs

@@ -98,7 +98,7 @@ pub async fn merge_queue_tick(ctx: Arc<BorsContext>) -> anyhow::Result<()> {
 }
 
 async fn process_repository(repo: &RepositoryState, ctx: &BorsContext) -> anyhow::Result<()> {
-    if !repo.config.load().merge_queue_enabled {
+    if !repo.config.load().merge_queue_enabled || repo.is_paused() {
         return Ok(());
     }
 

src/bors/mod.rs

@@ -19,6 +19,7 @@ use serde::Serialize;
 use std::collections::HashMap;
 use std::fmt;
 use std::str::FromStr;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, LazyLock, RwLock};
 use std::time::Duration;
 
@@ -75,6 +76,8 @@ pub fn format_help() -> &'static str {
         BorsCommand::OpenTree => {}
         BorsCommand::TreeClosed(_) => {}
         BorsCommand::Retry => {}
+        BorsCommand::Pause => {}
+        BorsCommand::Resume => {}
     }
 
     r#"
@@ -180,12 +183,20 @@ pub struct RepositoryState {
     pub client: GithubRepositoryClient,
     pub permissions: ArcSwap<UserPermissions>,
     pub config: ArcSwap<RepositoryConfig>,
+    pub paused: AtomicBool,
 }
 
 impl RepositoryState {
     pub fn repository(&self) -> &GithubRepoName {
         self.client.repository()
     }
+
+    pub fn set_paused(&self, state: bool) {
+        self.paused.store(state, Ordering::SeqCst);
+    }
+    pub fn is_paused(&self) -> bool {
+        self.paused.load(Ordering::SeqCst)
+    }
 }
 
 #[derive(Default)]

src/github/api/mod.rs

@@ -1,5 +1,6 @@
 use std::collections::HashMap;
 use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
 use std::time::Duration;
 
 use anyhow::Context;
@@ -161,10 +162,19 @@ async fn create_repo_state(
 
     let config = load_config(&client).await?;
 
+    // Start paused for now, as a cautionary measure
+    let paused = AtomicBool::new(true);
+
+    #[cfg(test)]
+    {
+        paused.store(false, std::sync::atomic::Ordering::SeqCst);
+    }
+
     Ok(RepositoryState {
         client,
         config: ArcSwap::new(Arc::new(config)),
         permissions: ArcSwap::new(Arc::new(permissions)),
+        paused,
     })
 }