github_sync: smarter target branch selection

Implement "sticky" target branch: if a series has an associated open
PR without merge-conflict, then do not consider other target branches.

The config allows for multiple target branches to be associated with
the same tag, for example:

  "tag_to_branch_mapping": {
    "tag": ["target1", "target2"]
  }

Whenever a series is being synced, KPD tries to apply it to each
target branch in order, stopping at the first successful apply.  Then
it opens/updates a tracking PR, and closes all other PRs for this
series.

This works fine most of the time. However, this logic may lead to
series suddenly switching branches. Example scenario:

* v1 successfully applied to target1, pr1 is created for it
  * submitter receives CI report with v1 applied to target1
* v2 fails to apply to target1, but succeeds on target2
  * KPD opens pr2 for target2, and closes pr1
  * submitter receives CI report with v2 applied to target2 with no
    indication that something happened

What should've happened in this case is pr1 labeled as
"merge-conflict" and target2 not tried.

The "stickiness" is implemented by checking existing PRs when
determining the list of target branches to apply the series to.

Signed-off-by: Ihor Solodrai <[email protected]>

Author: theihor

kernel_patches_daemon/github_sync.py

@@ -187,6 +187,34 @@ async def checkout_and_patch_safe(
             )
             return None
 
+    async def select_target_branches_for_subject(
+        self, subject: Subject, tag_mapped_branches: List[str]
+    ) -> List[str]:
+        if len(tag_mapped_branches) == 1:
+            return tag_mapped_branches
+
+        def has_merge_conflict_label(pr: PullRequest) -> bool:
+            for label in pr.get_labels():
+                if label.name == "merge-conflict":
+                    return True
+            return False
+
+        # Check if a single relevant open PR without merge conflicts exists.
+        # If yes, then pick it without trying other target branches.
+        subject_pr_targets = []
+        for branch in tag_mapped_branches:
+            worker = self.workers[branch]
+            subj_branch = await worker.subject_to_branch(subject)
+            for pr in worker.prs.values():
+                if pr.head.ref == subj_branch and not has_merge_conflict_label(pr):
+                    subject_pr_targets.append(branch)
+
+        if len(subject_pr_targets) == 1:
+            return [subject_pr_targets[0]]
+
+        # If no sticky target is determined, then return all branches
+        return tag_mapped_branches
+
     async def sync_relevant_subject(self, subject: Subject) -> None:
         """
         1. Get Subject's latest series
@@ -206,8 +234,11 @@ async def sync_relevant_subject(self, subject: Subject) -> None:
             )
             return
 
-        last_branch = mapped_branches[-1]
-        for branch in mapped_branches:
+        target_branches = await self.select_target_branches_for_subject(
+            subject, mapped_branches
+        )
+        last_branch = target_branches[-1]
+        for branch in target_branches:
             worker = self.workers[branch]
             # PR branch name == sid of the first known series
             pr_branch_name = await worker.subject_to_branch(subject)

tests/test_github_sync.py

@@ -17,7 +17,11 @@
 from kernel_patches_daemon.branch_worker import NewPRWithNoChangeException
 from kernel_patches_daemon.config import KPDConfig
 from kernel_patches_daemon.github_sync import GithubSync, HEAD_BASE_SEPARATOR
-from tests.common.patchwork_mock import init_pw_responses, load_test_data, PatchworkMock
+from tests.common.patchwork_mock import (
+    init_pw_responses,
+    load_test_data,
+    PatchworkMock,
+)
 
 TEST_BRANCH = "test-branch"
 TEST_BPF_NEXT_BRANCH = "test-bpf-next"
@@ -278,6 +282,43 @@ async def test_sync_relevant_subject_success_second_branch(self) -> None:
             list(self._gh.workers.values()), pr_mock
         )
 
+    def _setup_test_select_target_branches_for_subject(self):
+        series_prefix = "series/123123"
+        subject_mock = MagicMock()
+        subject_mock.subject = "Test subject"
+        subject_mock.branch = AsyncMock(return_value=series_prefix)
+
+        pr_mock = MagicMock()
+        pr_mock.head.ref = f"{series_prefix}{HEAD_BASE_SEPARATOR}{TEST_BPF_NEXT_BRANCH}"
+
+        worker_mock = self._gh.workers[TEST_BPF_NEXT_BRANCH]
+        worker_mock.prs = {subject_mock.subject: pr_mock}
+
+        return subject_mock, pr_mock
+
+    async def test_select_target_branches_for_subject(self) -> None:
+        subject_mock, _ = self._setup_test_select_target_branches_for_subject()
+        mapped_branches = [TEST_BRANCH, TEST_BPF_NEXT_BRANCH]
+
+        selected_branches = await self._gh.select_target_branches_for_subject(
+            subject_mock, mapped_branches
+        )
+
+        self.assertEqual(selected_branches, [TEST_BPF_NEXT_BRANCH])
+
+    async def test_select_target_branches_for_subject_merge_conflict(self) -> None:
+        subject_mock, pr_mock = self._setup_test_select_target_branches_for_subject()
+        label = MagicMock()
+        label.name = "merge-conflict"
+        pr_mock.get_labels = MagicMock(return_value=[label])
+        mapped_branches = [TEST_BRANCH, TEST_BPF_NEXT_BRANCH]
+
+        selected_branches = await self._gh.select_target_branches_for_subject(
+            subject_mock, mapped_branches
+        )
+
+        self.assertEqual(selected_branches, mapped_branches)
+
     @aioresponses()
     async def test_sync_patches_pr_summary_success(self, m: aioresponses) -> None:
         """