Auto-nominate for backport a pull request fixing a regression

apiraino · apiraino · commit 7a37ed9bd585 · 2025-07-08T16:21:08.000+02:00
diff --git a/src/config.rs b/src/config.rs
@@ -47,6 +47,7 @@ pub(crate) struct Config {
     pub(crate) issue_links: Option<IssueLinksConfig>,
     pub(crate) no_mentions: Option<NoMentionsConfig>,
     pub(crate) behind_upstream: Option<BehindUpstreamConfig>,
+    pub(crate) backport: Option<BackportTeamConfig>,
 }
 
 #[derive(PartialEq, Eq, Debug, serde::Deserialize)]
@@ -522,6 +523,25 @@ fn default_true() -> bool {
     true
 }
 
+#[derive(PartialEq, Eq, Debug, serde::Deserialize)]
+pub(crate) struct BackportTeamConfig {
+    // Config identifier -> labels
+    #[serde(flatten)]
+    pub(crate) configs: HashMap<String, BackportConfig>,
+}
+
+#[derive(Default, PartialEq, Eq, Debug, serde::Deserialize)]
+#[serde(rename_all = "kebab-case")]
+#[serde(deny_unknown_fields)]
+pub(crate) struct BackportConfig {
+    /// Prerequisite label(s) (one of them) to trigger this handler for a specific team
+    pub(crate) required_pr_labels: Vec<String>,
+    /// Prerequisite label for an issue to qualify as regression
+    pub(crate) required_issue_labels: String,
+    /// Labels to be added to a pull request closing the regression
+    pub(crate) add_labels: Vec<String>,
+}
+
 fn get_cached_config(repo: &str) -> Option<Result<Arc<Config>, ConfigurationError>> {
     let cache = CONFIG_CACHE.read().unwrap();
     cache.get(repo).and_then(|(config, fetch_time)| {
@@ -655,6 +675,11 @@ mod tests {
 
             [behind-upstream]
             days-threshold = 14
+
+            [backport.teamRed]
+            required-pr-labels = ["T-libs", "T-libs-api"]
+            required-issue-labels = "regression-from-stable-to-stable"
+            add-labels = ["stable-nominated"]
         "#;
         let config = toml::from_str::<Config>(&config).unwrap();
         let mut ping_teams = HashMap::new();
@@ -679,6 +704,20 @@ mod tests {
         nominate_teams.insert("release".to_owned(), "T-release".to_owned());
         nominate_teams.insert("core".to_owned(), "T-core".to_owned());
         nominate_teams.insert("infra".to_owned(), "T-infra".to_owned());
+
+        let mut backport_configs = HashMap::new();
+        backport_configs.insert(
+            "teamRed".into(),
+            BackportConfig {
+                required_pr_labels: vec!["T-libs".into(), "T-libs-api".into()],
+                required_issue_labels: "regression-from-stable-to-stable".into(),
+                add_labels: vec!["stable-nominated".into()],
+            },
+        );
+        let backport_team_config = BackportTeamConfig {
+            configs: backport_configs,
+        };
+
         assert_eq!(
             config,
             Config {
@@ -727,6 +766,7 @@ mod tests {
                 concern: Some(ConcernConfig {
                     labels: vec!["has-concerns".to_string()],
                 }),
+                backport: Some(backport_team_config)
             }
         );
     }
@@ -812,6 +852,7 @@ mod tests {
                 behind_upstream: Some(BehindUpstreamConfig {
                     days_threshold: Some(7),
                 }),
+                backport: None
             }
         );
     }
diff --git a/src/handlers.rs b/src/handlers.rs
@@ -28,6 +28,7 @@ impl fmt::Display for HandlerError {
 
 mod assign;
 mod autolabel;
+mod backport;
 mod bot_pull_requests;
 mod check_commits;
 mod close;
@@ -225,6 +226,7 @@ macro_rules! issue_handlers {
 issue_handlers! {
     assign,
     autolabel,
+    backport,
     issue_links,
     major_change,
     mentions,
diff --git a/src/handlers/backport.rs b/src/handlers/backport.rs
@@ -0,0 +1,241 @@
+use std::collections::HashMap;
+use std::sync::LazyLock;
+
+use crate::config::BackportTeamConfig;
+use crate::github::{IssuesAction, IssuesEvent, Label};
+use crate::handlers::Context;
+use anyhow::Context as AnyhowContext;
+use regex::Regex;
+use tracing as log;
+
+// See https://docs.github.com/en/issues/tracking-your-work-with-issues/creating-issues/linking-a-pull-request-to-an-issue
+// See tests to see what matches
+static CLOSES_ISSUE_REGEXP: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new("(?i)(?P<action>close[sd]*|fix([e]*[sd]*)?|resolve[sd]*)(?P<spaces>:? +)(?P<org_repo>[a-zA-Z0-9_-]*/[a-zA-Z0-9_-]*)?#(?P<issue_num>[0-9]+)").unwrap()
+});
+
+const BACKPORT_LABELS: [&str; 4] = [
+    "beta-nominated",
+    "beta-accepted",
+    "stable-nominated",
+    "stable-accepted",
+];
+
+const REGRESSION_LABELS: [&str; 3] = [
+    "regression-from-stable-to-nightly",
+    "regression-from-stable-to-beta",
+    "regression-from-stable-to-stable",
+];
+
+#[derive(Default)]
+pub(crate) struct BackportInput {
+    // Issue(s) fixed by this PR
+    ids: Vec<u64>,
+    // Labels profile, compound value of (required_issue_labels -> add_labels)
+    profile_labels: HashMap<String, Vec<String>>,
+}
+
+pub(super) async fn parse_input(
+    _ctx: &Context,
+    event: &IssuesEvent,
+    config: Option<&BackportTeamConfig>,
+) -> Result<Option<BackportInput>, String> {
+    let config = match config {
+        Some(config) => config,
+        None => return Ok(None),
+    };
+
+    // Only handle events when the PR is opened or the first comment is edited
+    if !matches!(event.action, IssuesAction::Opened | IssuesAction::Edited) && !event.issue.is_pr()
+    {
+        log::info!(
+            "Skipping backport event because: IssuesAction = {:?} issue.is_pr() {}",
+            event.action,
+            event.issue.is_pr()
+        );
+        return Ok(None);
+    }
+    let pr = &event.issue;
+
+    let pr_labels: Vec<&str> = pr.labels.iter().map(|l| l.name.as_str()).collect();
+    if contains_any(&pr_labels, &BACKPORT_LABELS) {
+        log::debug!("PR #{} already has a backport label", pr.number);
+        return Ok(None);
+    }
+
+    // Retrieve backport config for this PR, based on its team label(s)
+    // If the PR has no team label matching any [backport.*.required_pr_labels] config, the backport labelling will be skipped
+    let mut input = BackportInput::default();
+    let valid_configs: Vec<_> = config
+        .configs
+        .iter()
+        .clone()
+        .filter(|(_cfg_name, cfg)| {
+            let required_pr_labels: Vec<&str> =
+                cfg.required_pr_labels.iter().map(|l| l.as_str()).collect();
+            if !contains_any(&pr_labels, &required_pr_labels) {
+                log::warn!(
+                    "Skipping backport nomination: PR is missing one required team label: {:?}",
+                    pr_labels
+                );
+                return false;
+            }
+            input
+                .profile_labels
+                .insert(cfg.required_issue_labels.clone(), cfg.add_labels.clone());
+            true
+        })
+        .collect();
+    if valid_configs.is_empty() {
+        log::warn!(
+            "Skipping backport nomination: could not find a suitable backport config. Please ensure the triagebot.toml has a `[backport.*.required_pr_labels]` section matching the team label(s) for PR #{}.",
+            pr.number
+        );
+        return Ok(None);
+    }
+
+    // Check marker text in the opening comment of the PR to retrieve the issue(s) being fixed
+    for caps in CLOSES_ISSUE_REGEXP.captures_iter(&event.issue.body) {
+        let id = caps.name("issue_num").unwrap().as_str();
+        let id = match id.parse::<u64>() {
+            Ok(id) => id,
+            Err(err) => {
+                return Err(format!("Failed to parse issue id `{id}`, error: {err}"));
+            }
+        };
+        input.ids.push(id);
+    }
+    log::info!(
+        "Will handle event action {:?} in backport. Regression IDs found {:?}",
+        event.action,
+        input.ids
+    );
+
+    Ok(Some(input))
+}
+
+pub(super) async fn handle_input(
+    ctx: &Context,
+    _config: &BackportTeamConfig,
+    event: &IssuesEvent,
+    input: BackportInput,
+) -> anyhow::Result<()> {
+    let pr = &event.issue;
+
+    // Retrieve the issue(s) this pull request closes
+    let issues = input
+        .ids
+        .iter()
+        .copied()
+        .map(|id| async move { event.repository.get_issue(&ctx.github, id).await });
+
+    // auto-nominate for backport only patches fixing high/critical regressions
+    // For `P_{medium,low}` regressions, let the author decide
+    let priority_labels = ["P-high", "P-critical"];
+
+    // Add backport nomination label to the pull request
+    for issue in issues {
+        let issue = issue.await.unwrap();
+        let mut regression_label = String::new();
+        let issue_labels: Vec<&str> = issue
+            .labels
+            .iter()
+            .map(|l| {
+                // save regression label for later
+                if l.name.starts_with("regression-from-") {
+                    regression_label = l.name.clone();
+                }
+                l.name.as_str()
+            })
+            .collect();
+
+        // Check issue for a prerequisite regression label
+        if regression_label.is_empty() || !contains_any(&REGRESSION_LABELS, &[&regression_label]) {
+            return Ok(());
+        }
+
+        // Check issue for a prerequisite priority label
+        if !contains_any(&issue_labels, &priority_labels) {
+            return Ok(());
+        }
+
+        // figure out the labels to be added according to the regression label
+        let add_labels = input.profile_labels.get(&regression_label);
+        if add_labels.is_none() {
+            log::warn!(
+                "Skipping backport nomination: nothing to do for issue #{}. No config found for regression label ({:?})",
+                issue.number,
+                REGRESSION_LABELS
+            );
+            return Ok(());
+        }
+
+        // Add backport nomination label(s) to PR
+        let mut new_labels = pr.labels().to_owned();
+        new_labels.extend(
+            add_labels
+                .unwrap()
+                .iter()
+                .cloned()
+                .map(|name| Label { name }),
+        );
+        log::debug!(
+            "PR#{} adding labels for backport {:?}",
+            pr.number,
+            new_labels
+        );
+        return pr
+            .add_labels(&ctx.github, new_labels)
+            .await
+            .context("failed to add backport labels to the PR");
+    }
+
+    Ok(())
+}
+
+fn contains_any(haystack: &[&str], needles: &[&str]) -> bool {
+    needles.iter().any(|needle| haystack.contains(needle))
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::handlers::backport::CLOSES_ISSUE_REGEXP;
+
+    #[tokio::test]
+    async fn backport_match_comment() {
+        let test_strings = vec![
+            ("close #10", vec![10]),
+            ("closes #10", vec![10]),
+            ("closed #10", vec![10]),
+            ("Closes #10", vec![10]),
+            ("close  #10", vec![10]),
+            ("close rust-lang/rust#10", vec![10]),
+            ("cLose: rust-lang/rust#10", vec![10]),
+            ("fix #10", vec![10]),
+            ("fixes #10", vec![10]),
+            ("fixed #10", vec![10]),
+            ("resolve #10", vec![10]),
+            ("resolves #10", vec![10]),
+            ("resolved #10", vec![10]),
+            (
+                "Fixes #20, Resolves #21, closed #22, LOL #23",
+                vec![20, 21, 22],
+            ),
+            ("Resolved #10", vec![10]),
+            ("Fixes #10", vec![10]),
+            ("Closes #10", vec![10]),
+        ];
+        for test_case in test_strings {
+            let mut ids: Vec<u64> = vec![];
+            let test_str = test_case.0;
+            let expected = test_case.1;
+            for caps in CLOSES_ISSUE_REGEXP.captures_iter(test_str) {
+                // eprintln!("caps {:?}", caps);
+                let id = &caps["issue_num"];
+                ids.push(id.parse::<u64>().unwrap());
+            }
+            // eprintln!("ids={:?}", ids);
+            assert_eq!(ids, expected);
+        }
+    }
+}
