Add a slack notification for open automated PRs before an iOS merge day

Author: DonalMe

.github/workflows/ios-open-pr-slack.yml

@@ -0,0 +1,40 @@
+name: Firefox iOS open PR Slack announcement
+
+on:
+  schedule:
+    # Thursdays at 16:00 UTC — the day before we branch for release,
+    # this gives time for folks to review and merge.
+    - cron: '0 16 * * 4'
+  workflow_dispatch:
+    inputs:
+      dry_run:
+        description: 'Print the message instead of posting to Slack'
+        required: false
+        type: boolean
+        default: true
+      test_date:
+        description: 'Pretend today is this date (YYYY-MM-DD), e.g. 2026-08-27'
+        required: false
+        type: string
+
+jobs:
+  announce:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Remind if there are any open automated PRs pending before we branch
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.IOS_DEV_SLACK_WEBHOOK }}
+          DRY_RUN: ${{ inputs.dry_run }}
+          TEST_DATE: ${{ inputs.test_date }}
+        run: python3 app/scripts/ios_open_pr_slack_notifier.py

app/scripts/ios_open_pr_slack_notifier.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+Reminds firefox-ios-dev about automated pull requests still open before we branch.
+
+The l10n import and similar housekeeping PRs are opened by GitHub Actions and can sit
+unreviewed. Anything still open when we branch misses the release, so this posts a
+nudge while there is time to land them.
+
+Run weekly by .github/workflows/ios-open-pr-slack.yml, on Thursday, the day before we
+branch. Posts nothing when the queue is empty or when no merge day is imminent, so a
+quiet week is silent rather than noisy.
+
+Merge day is normally the Friday. When that Friday is a wellness day the merge moves
+back onto the Thursday, so the message says "today" and gives the reason instead of
+claiming a branch that is not happening tomorrow.
+
+Requires the SLACK_WEBHOOK_URL environment variable (set from the
+IOS_DEV_SLACK_WEBHOOK repo secret in the workflow).
+
+Env vars for testing:
+  DRY_RUN=1           print the message instead of posting it. Accepts
+                      1/true/yes/on to enable and 0/false/no/off or empty to
+                      disable; anything else is an error rather than a guess.
+  TEST_DATE=Y-m-d     pretend today is this date, to exercise a merge day that
+                      isn't today (e.g. 2026-08-27 for the wellness case)
+"""
+import os
+import sys
+from datetime import date, datetime, timedelta
+
+from lib.env import env_flag
+from lib.fetch import fetch_json
+from lib.schedule import ios_merge_days, today as utc_today
+from lib.slack import post_to_slack
+
+REPO = "mozilla-mobile/firefox-ios"
+# The GitHub Actions app, which opens the l10n import PRs. "app/" is how GitHub's
+# search addresses an app rather than a user; the PRs show up as github-actions[bot].
+AUTHOR = "app/github-actions"
+
+SEARCH_URL = (
+    "https://api.github.com/search/issues"
+    f"?q=repo:{REPO}+is:pr+is:open+author:{AUTHOR}"
+    "&sort=created&order=asc&per_page=100"
+)
+
+# When the branch happens, which is what makes the ask urgent. Merge day is normally
+# the Friday after this Thursday run; a wellness day moves it back onto the Thursday,
+# in which case say so, since "tomorrow" would be wrong and the reason is not obvious.
+BRANCH_TOMORROW = "We'll be branching from main tomorrow for release."
+BRANCH_TODAY_WELLNESS = (
+    "We'll be branching from main today for release, as tomorrow is a wellness day."
+)
+BRANCH_TODAY = "We'll be branching from main today for release."
+
+# One PR reads oddly with the plural ask, so it gets its own wording.
+ASK_ONE = "There is an automated PR pending, could it be reviewed and merged?"
+ASK_MANY = (
+    "There are {count} automated PRs pending, could they be reviewed and merged?"
+)
+# The title carries the link, so the whole bullet is clickable. Slack has no list
+# markdown — a literal bullet character is how you get a list.
+LINE = "• <{url}|{title}>"
+
+
+def open_prs() -> list[dict]:
+    """The open PRs by AUTHOR, oldest first — the oldest has waited longest."""
+    result = fetch_json(SEARCH_URL)
+    if result.get("incomplete_results"):
+        # A timed-out search returns a partial list, which would understate the queue.
+        print("GitHub reported incomplete search results.", file=sys.stderr)
+    return result["items"]
+
+
+THURSDAY = 3
+
+
+def branch_sentence(today: date) -> str | None:
+    """
+    How to describe the upcoming branch, or None when there isn't one to describe.
+
+    None is the "no merge this week" case, and means nothing gets posted: the ask
+    only makes sense when a branch is about to strand whatever is still open.
+    """
+    days = ios_merge_days()
+
+    if today + timedelta(days=1) in days:
+        return BRANCH_TOMORROW
+
+    if today in days:
+        # Merge days are Fridays. One on a Thursday has been moved back off the
+        # Friday, and a wellness day is the reason that happens.
+        if today.weekday() == THURSDAY:
+            return BRANCH_TODAY_WELLNESS
+        return BRANCH_TODAY
+
+    return None
+
+
+def build_message(prs: list[dict], branch: str) -> str:
+    """The Slack message for a non-empty list of PRs."""
+    ask = ASK_ONE if len(prs) == 1 else ASK_MANY.format(count=len(prs))
+    lines = [f"{branch} {ask}"]
+    lines += [
+        LINE.format(url=pr["html_url"], title=pr["title"]) for pr in prs
+    ]
+    return "\n".join(lines)
+
+
+def main() -> int:
+    dry_run = env_flag("DRY_RUN")
+    webhook_url = os.environ.get("SLACK_WEBHOOK_URL")
+    if not webhook_url and not dry_run:
+        print("SLACK_WEBHOOK_URL is not set — nothing to do.", file=sys.stderr)
+        return 1
+
+    test_date = os.environ.get("TEST_DATE")
+    if test_date:
+        today = datetime.strptime(test_date, "%Y-%m-%d").date()
+        print(f"TEST MODE: pretending today is {today}")
+    else:
+        today = utc_today()
+
+    # Check the schedule first: with no branch coming there is nothing to ask for,
+    # however many PRs are open.
+    branch = branch_sentence(today)
+    if branch is None:
+        print(f"{today}: no iOS merge day today or tomorrow. Nothing to post.")
+        return 0
+
+    prs = open_prs()
+    if not prs:
+        print(f"{today}: no open automated PRs in {REPO}. Nothing to post.")
+        return 0
+
+    text = build_message(prs, branch)
+
+    if dry_run:
+        print(f"DRY RUN — would post:\n{text}")
+        return 0
+
+    post_to_slack(webhook_url, text)
+    print(f"{today}: posted a reminder about {len(prs)} open automated PR(s).")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

app/scripts/ios_release_slack_notifier.py

@@ -41,10 +41,14 @@
 
 from lib.env import env_flag
 from lib.fetch import RETRYABLE, fetch, fetch_json
-from lib.schedule import channel_versions, parse_date, today as utc_today
+from lib.schedule import (
+    channel_versions,
+    fetch_ios_schedule,
+    parse_date,
+    today as utc_today,
+)
 from lib.slack import post_to_slack
 
-IOS_SCHEDULE_URL = "https://whattrainisitnow.com/api/release/schedule/ios/?version={}"
 # Firefox iOS App Store listing. Unknown query parameters form part of Apple's cache
 # key, so filling the unused one with the current time asks for a URL no edge node
 # holds yet, which gets us today's answer rather than yesterday's.
@@ -115,7 +119,7 @@ def expected_version(major: int, today: date) -> str | None:
     Dot releases shipped inbetween release_0 and release_1 use the pattern {major}.N.X, for example 153.0.1
     These versions are not covered by the slack notification automation since they are ad-hoc
     """
-    schedule = fetch_json(IOS_SCHEDULE_URL.format(major))
+    schedule = fetch_ios_schedule(major)
 
     # Sorted numerically once, so the lookup and the log line cannot disagree:
     # a plain sort would order release_10 before release_2.

app/scripts/lib/schedule.py

@@ -4,8 +4,18 @@
 from .fetch import fetch_json
 
 API_URL = "https://whattrainisitnow.com/api/release/schedule/?version={}"
+IOS_API_URL = "https://whattrainisitnow.com/api/release/schedule/ios/?version={}"
+
+# Which majors carry the merge days worth knowing about: Release and Beta.
+#
+# A major's merge days all fall before it ships, so the next one belongs to Beta.
+# Release is included because Nightly advances during merge day itself, which shifts
+# what Beta means on exactly the day the answer has to be right. Since Release always
+# trails Beta by one, the pair covers the same dates either side of that rollover.
+IOS_MERGE_CHANNELS = ("release", "beta")
 
 _schedules: dict[str, dict] = {}
+_ios_schedules: dict[str, dict] = {}
 
 
 def parse_date(value: str) -> datetime.date:
@@ -49,3 +59,32 @@ def channel_versions() -> dict[str, int]:
         "beta": nightly - 1,
         "nightly": nightly,
     }
+
+
+def fetch_ios_schedule(major: int | str) -> dict:
+    """Fetch a Firefox iOS major's milestone dates from the whattrainisitnow API."""
+    key = str(major)
+    if key not in _ios_schedules:
+        _ios_schedules[key] = fetch_json(IOS_API_URL.format(key))
+
+    return _ios_schedules[key]
+
+
+def ios_merge_days() -> set[datetime.date]:
+    """
+    Every iOS merge day in the Release and Beta schedules. See IOS_MERGE_CHANNELS.
+
+    A merge day is normally a Friday. One that lands on a Thursday has been moved
+    back off a Friday that is a wellness day.
+    """
+    versions = channel_versions()
+    days: set[datetime.date] = set()
+    for channel in IOS_MERGE_CHANNELS:
+        schedule = fetch_ios_schedule(versions[channel])
+        days |= {
+            parse_date(value)
+            for key, value in schedule.items()
+            if key.startswith("merge_day")
+        }
+
+    return days