src/maintenance-prs.ts

Functions

Imports

It imports src/auto-merge-policy.ts, src/env.ts, src/github/client.ts, src/github/pr-files.ts, src/maintenance.ts, src/time.ts. Imported by src/maintenance.ts.

Source

1import type { Env } from "./env";
2import { ghFetch, resolveRepo } from "./github/client";
3import { readAllPages, readCheckRuns } from "./github/pr-files";
4import { ciVerdict, jobIdFromBody } from "./auto-merge-policy";
5import type { MaintenanceItem } from "./maintenance";
6import { HOUR_MS, DAY_MS } from "./time";
7
8// The daily maintenance pass's pull request rules (job_549550d73d4e, piece 2). Two lists:
9// a green driver pull request that is still open is waiting for the seat, shown with its
10// age; a pull request whose checks have been red for more than 48 hours is shown with the
11// step that failed. Both read what the auto-merge tick reads (the open list and each head's
12// check runs, judged by the same ciVerdict), never the file lists. A read that fails is
13// listed as "not checked", so a missing read never passes as a clean result.
14
15const RED_HOURS = 48;
16// Open pull requests read per repo. More are reported as not checked, not silently cut.
17const PRS_READ_PER_REPO = 50;
18const OPEN_LIST_MAX_PAGES = 2;
19const CHECKS_MAX_PAGES = 10;
20const MAX_ITEMS_PER_RULE = 50;
21
22export interface PrCheck {
23  id: number;
24  name: string;
25  status: string;
26  conclusion: string | null;
27  completed_at: string | null;
28  /** A GitHub Actions job, whose check run id is the job id and so has steps to read. */
29  actions: boolean;
30}
31
32export interface OpenPr {
33  number: number;
34  url: string;
35  draft: boolean;
36  created_at: string;
37  /** The job the body names, which is what makes it a driver's pull request. */
38  job: string | null;
39  checks: PrCheck[];
40}
41
42export interface PrReaders {
43  /** The open pull requests of the namespace's repo with their head's check runs. May
44   *  throw; `problem` says what part was not read. */
45  openPrs(namespace: string): Promise<{ repo: string; prs: OpenPr[]; problem: string | null }>;
46  /** The failed step of a failed check run, or why it was not read. */
47  failingStep(repo: string, check: PrCheck): Promise<{ step: string | null; problem: string | null }>;
48}
49
50const days = (ms: number): string => `${(ms / DAY_MS).toFixed(1)} days`;
51
52/** A driver's pull request, not a draft, whose checks are all green: it waits for the seat. */
53export function greenAwaitingSeat(namespace: string, prs: OpenPr[], now: Date): MaintenanceItem[] {
54  return prs
55    .filter((pr) => pr.job !== null && !pr.draft && ciVerdict(pr.checks).conclusion === "success")
56    .sort((a, b) => a.created_at.localeCompare(b.created_at))
57    .map((pr) => ({
58      rule: "pr-awaiting-seat" as const,
59      namespace,
60      job: pr.job,
61      pr: pr.url,
62      line: `${pr.url} (${pr.job}) is green and has been open ${days(now.getTime() - Date.parse(pr.created_at))}: merge it or say why it waits.`,
63    }));
64}
65
66/** A pull request whose checks have all finished, at least one failed, and the first
67 *  failure finished more than RED_HOURS ago on the current head. A re-run or a new push
68 *  starts the clock again, because GitHub then reports new check runs. */
69export function redTooLong(prs: OpenPr[], now: Date): Array<{ pr: OpenPr; since: string; check: PrCheck }> {
70  const out: Array<{ pr: OpenPr; since: string; check: PrCheck }> = [];
71  for (const pr of prs) {
72    if (ciVerdict(pr.checks).conclusion !== "failure") continue;
73    const failed = pr.checks
74      .filter((c) => !["success", "skipped", "neutral"].includes(c.conclusion ?? "") && c.completed_at)
75      .sort((a, b) => (a.completed_at ?? "").localeCompare(b.completed_at ?? ""));
76    const first = failed[0];
77    if (!first?.completed_at) continue;
78    if (now.getTime() - Date.parse(first.completed_at) > RED_HOURS * HOUR_MS) out.push({ pr, since: first.completed_at, check: first });
79  }
80  return out;
81}
82
83/** The pull request rules over every namespace in `namespaces`, and how many open pull
84 *  requests each read, so "nothing listed" can be told from "nothing read". */
85export async function gatherPrItems(
86  namespaces: readonly string[],
87  readers: PrReaders,
88  now: Date
89): Promise<{ items: MaintenanceItem[]; read: Record<string, number> }> {
90  const items: MaintenanceItem[] = [];
91  const read: Record<string, number> = {};
92  for (const namespace of namespaces) {
93    let got: Awaited<ReturnType<PrReaders["openPrs"]>>;
94    try {
95      got = await readers.openPrs(namespace);
96    } catch (err) {
97      items.push(notChecked(namespace, err instanceof Error ? err.message : String(err)));
98      continue;
99    }
100    read[namespace] = got.prs.length;
101    if (got.problem) items.push(notChecked(namespace, got.problem));
102    items.push(...greenAwaitingSeat(namespace, got.prs, now).slice(0, MAX_ITEMS_PER_RULE));
103    for (const { pr, since, check } of redTooLong(got.prs, now).slice(0, MAX_ITEMS_PER_RULE)) {
104      let where: string;
105      try {
106        const step = await readers.failingStep(got.repo, check);
107        where = step.step ? `"${check.name}" failed at step "${step.step}"` : `"${check.name}" failed; its step was not read (${step.problem ?? "unknown"})`;
108      } catch (err) {
109        where = `"${check.name}" failed; its step was not read (${err instanceof Error ? err.message : String(err)})`;
110      }
111      items.push({
112        rule: "pr-red",
113        namespace,
114        job: pr.job,
115        pr: pr.url,
116        line: `${pr.url} has been red for ${days(now.getTime() - Date.parse(since))}: ${where}. Fix it or close it.`,
117      });
118    }
119  }
120  return { items, read };
121}
122
123function notChecked(namespace: string, problem: string): MaintenanceItem {
124  return {
125    rule: "prs-not-checked",
126    namespace,
127    job: null,
128    line: `Open pull requests in ${namespace} were not fully checked (${problem}): what is missing is not a clean result.`,
129  };
130}
131
132interface RawPr {
133  number: number;
134  html_url: string;
135  draft?: boolean;
136  created_at: string;
137  body: string | null;
138  head: { sha: string };
139}
140
141interface RawCheck {
142  id: number;
143  name: string;
144  status: string;
145  conclusion: string | null;
146  completed_at: string | null;
147  app?: { slug?: string } | null;
148}
149
150/** The readers on GitHub, through the App: the same open list and check-run reads the
151 *  auto-merge tick makes (src/auto-merge-tick.ts), and one Actions job read per pull
152 *  request that has been red long enough to be listed. */
153export function githubPrReaders(env: Env): PrReaders {
154  return {
155    async openPrs(namespace) {
156      const { owner, repo, full } = await resolveRepo(env, namespace);
157      const listed = await readAllPages<RawPr>(env, owner, repo, `/repos/${owner}/${repo}/pulls?state=open`, (page) => page as RawPr[], OPEN_LIST_MAX_PAGES);
158      const problems: string[] = [];
159      if (listed.problem) problems.push(`the open pull request list: ${listed.problem}`);
160      const reading = listed.items.slice(0, PRS_READ_PER_REPO);
161      if (listed.items.length > reading.length) problems.push(`${listed.items.length - reading.length} open pull requests were not read`);
162      const prs: OpenPr[] = [];
163      for (const pr of reading) {
164        const checks = await readCheckRuns<RawCheck>(env, owner, repo, pr.head.sha, CHECKS_MAX_PAGES);
165        if (checks.problem) {
166          problems.push(`#${pr.number} check runs: ${checks.problem}`);
167          continue;
168        }
169        prs.push({
170          number: pr.number,
171          url: pr.html_url,
172          draft: pr.draft === true,
173          created_at: pr.created_at,
174          job: jobIdFromBody(pr.body ?? ""),
175          checks: checks.items.map((c) => ({
176            id: c.id,
177            name: c.name,
178            status: c.status,
179            conclusion: c.conclusion,
180            completed_at: c.completed_at,
181            actions: c.app?.slug === "github-actions",
182          })),
183        });
184      }
185      return { repo: full, prs, problem: problems.length > 0 ? problems.join("; ") : null };
186    },
187    async failingStep(repo, check) {
188      if (!check.actions) return { step: null, problem: "it is not a GitHub Actions job, so it has no steps" };
189      const [owner, name] = repo.split("/");
190      const resp = await ghFetch(env, owner, name, `/repos/${owner}/${name}/actions/jobs/${check.id}`);
191      if (!resp.ok) {
192        await resp.body?.cancel();
193        return { step: null, problem: `the job read returned ${resp.status}` };
194      }
195      const job = (await resp.json()) as { steps?: Array<{ name: string; conclusion: string | null }> };
196      const step = job.steps?.find((s) => s.conclusion === "failure")?.name ?? null;
197      return { step, problem: step ? null : "no step of the job is marked failed" };
198    },
199  };
200}