From 3146dd51a89658019e5b47635129c15279d001bd Mon Sep 17 00:00:00 2001 From: DanielRyanSmith <56164590+DanielRyanSmith@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:33:26 +0000 Subject: [PATCH] Don't let one failed WebKit export check crash the poller The WebKit export poller handled each pull request in an async `forEach` callback. The surrounding `try`/`catch` doesn't see errors thrown in those callbacks, so any failure became an unhandled rejection, which exits the process on current Node. One bad response from bugs.webkit.org (or GitHub, or Specref) for one PR therefore killed the whole poll before any PR was approved, and the instance with it. This happened on both full polls after #274 was deployed. Empty responses from bugs.webkit.org (for the history of bug 283585, then for bug 298271) crashed the process ~37s into each poll, so none of the export PRs that were waiting for approval got approved. Move the poller into `lib/webkit-poller.js` so it can be tested, and handle the pull requests one at a time, catching and logging errors for each so that the rest are still checked. Skipped PRs are retried on the next poll. Handling them one at a time also stops the poller from sending ~100 simultaneous requests to bugs.webkit.org. As before, a failure to add labels is logged and doesn't stop the PR from being approved. Some or all of the code in this commit was generated by an AI agent. Assisted-by: AI agent --- index.js | 38 +-------- lib/webkit-poller.js | 84 +++++++++++++++++++ test/webkit-poller.js | 189 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 276 insertions(+), 35 deletions(-) create mode 100644 lib/webkit-poller.js create mode 100644 test/webkit-poller.js diff --git a/index.js b/index.js index 9d95e49..c71feea 100644 --- a/index.js +++ b/index.js @@ -15,8 +15,8 @@ const bl = require("bl"), github = require('./lib/github'), labelModel = require('./lib/label-model'), logger = require('./lib/logger'), - secretsManager = require('./create-secrets'), - webkit = require('./lib/metadata/webkit'); + pollWebKitExports = require('./lib/webkit-poller'), + secretsManager = require('./create-secrets'); flags.defineBoolean('dry-run', false, 'Run in dry-run mode (no POSTs to GitHub)'); flags.parse(); @@ -126,39 +126,7 @@ async function pullRequestPoller() { logger.info('Checking for changes to WebKit-exported pull requests'); try { - const pull_requests = await github.get("/repos/:owner/:repo/pulls", {}); - pull_requests.forEach(async function(pull_request) { - if (!webkit.related(pull_request.title)) { - return; - } - const metadata = await get_metadata( - pull_request.number, - pull_request.user.login, - pull_request.title, - pull_request.body); - - const n = pull_request.number; - - logger.info({webkitExport: { - issue: metadata.issue, - title: metadata.title, - labels: metadata.labels, - isWebKitVerified: metadata.isWebKitVerified, - isMergeable: metadata.isMergeable, - reviewedDownstream: metadata.reviewedDownstream, - flags: metadata.webkit.flags || {}, - }}, `#${n}: Labelling and approving WebKit issue, if necessary`); - - return labelModel.post(n, metadata.labels, flags.get('dry-run')).then( - funkLogMsg(n, "Added missing LABELS if any."), - funkLogErr(n, "Something went wrong while adding missing LABELS.") - ).then(function() { - return comment(n, metadata, flags.get('dry-run')); - }).then( - funkLogMsg(n, "Added missing REVIEWERS if any."), - funkLogErr(n, "Something went wrong while adding missing REVIEWERS.") - ); - }); + await pollWebKitExports(flags.get('dry-run')); } catch (e) { // Assume that errors are likely recoverable, so log them and try again // next time. diff --git a/lib/webkit-poller.js b/lib/webkit-poller.js new file mode 100644 index 0000000..a217bb1 --- /dev/null +++ b/lib/webkit-poller.js @@ -0,0 +1,84 @@ +"use strict"; + +const comment = require('./comment'), + getMetadata = require('./metadata'), + github = require('./github'), + labelModel = require('./label-model'), + logger = require('./logger'), + webkit = require('./metadata/webkit'); + +const defaultDeps = { + comment: comment, + getMetadata: getMetadata, + github: github, + labelModel: labelModel, + logger: logger, + webkit: webkit, +}; + +/** + * Checks every open WebKit-exported pull request once, adding any missing + * labels and approving it if the WebKit patch has been reviewed downstream. + * + * Pull requests are handled one at a time, both to limit the load on + * bugs.webkit.org and so that an error while handling one pull request (e.g. a + * failed request to bugs.webkit.org) is logged and skipped rather than + * stopping the others from being checked. Previously such an error was an + * unhandled rejection, which crashed the process. Skipped pull requests are + * retried on the next poll. + * + * @param {boolean} dryRun Whether to avoid making changes on GitHub. + * @param {object} [deps] Overrides for the modules used; for testing. + * @returns {Promise} The numbers of the pull requests that could not + * be handled. + */ +module.exports = async function pollWebKitExports(dryRun, deps) { + deps = deps || defaultDeps; + const log = deps.logger; + + const pullRequests = await deps.github.get('/repos/:owner/:repo/pulls', {}); + const failed = []; + let checked = 0; + for (const pullRequest of pullRequests) { + if (!deps.webkit.related(pullRequest.title)) { + continue; + } + checked++; + const n = pullRequest.number; + try { + const metadata = await deps.getMetadata( + n, + pullRequest.user.login, + pullRequest.title, + pullRequest.body); + + log.info({webkitExport: { + issue: metadata.issue, + title: metadata.title, + labels: metadata.labels, + isWebKitVerified: metadata.isWebKitVerified, + isMergeable: metadata.isMergeable, + reviewedDownstream: metadata.reviewedDownstream, + flags: (metadata.webkit && metadata.webkit.flags) || {}, + }}, `#${n}: Labelling and approving WebKit issue, if necessary`); + + // As before, a failure to add labels is logged but doesn't stop + // the pull request from being approved. + try { + await deps.labelModel.post(n, metadata.labels, dryRun); + log.info(`#${n}: Added missing LABELS if any.`); + } catch (e) { + log.error(e, `#${n}: Something went wrong while adding missing LABELS.`); + } + + await deps.comment(n, metadata, dryRun); + log.info(`#${n}: Added missing REVIEWERS if any.`); + } catch (e) { + failed.push(n); + log.error(e, `#${n}: Unable to check WebKit export; will retry on the next poll.`); + } + } + + log.info(`Checked ${checked} WebKit-exported pull requests; ${failed.length} failed.`); + return failed; +}; diff --git a/test/webkit-poller.js b/test/webkit-poller.js new file mode 100644 index 0000000..9fcf3c2 --- /dev/null +++ b/test/webkit-poller.js @@ -0,0 +1,189 @@ +'use strict'; + +var assert = require('chai').assert, + pollWebKitExports = require('../lib/webkit-poller'); + +function pr(number, title) { + return { + number: number, + title: title || `WebKit export of https://bugs.webkit.org/show_bug.cgi?id=${number}`, + user: { login: 'someuser' }, + body: 'body', + }; +} + +/** + * Builds fake dependencies for the poller. `overrides` can replace + * getMetadata, labelPost or comment for specific behaviour. + */ +function fakeDeps(pullRequests, overrides) { + overrides = overrides || {}; + const calls = { getMetadata: [], labelPost: [], comment: [], info: [], error: [] }; + let inFlight = 0; + calls.maxInFlight = 0; + + async function tracked(fn) { + inFlight++; + calls.maxInFlight = Math.max(calls.maxInFlight, inFlight); + try { + // Yield so that concurrent processing would be observable. + await new Promise(resolve => setImmediate(resolve)); + return await fn(); + } finally { + inFlight--; + } + } + + const deps = { + github: { + get: async (path) => { + assert.equal(path, '/repos/:owner/:repo/pulls'); + return pullRequests; + }, + }, + webkit: require('../lib/metadata/webkit'), + getMetadata: (number, login, title, body) => tracked(async () => { + calls.getMetadata.push(number); + if (overrides.getMetadata) { + return overrides.getMetadata(number, login, title, body); + } + return { + issue: number, + title: title, + labels: ['webkit-export'], + isWebKitVerified: true, + reviewedDownstream: 'WebKit', + webkit: { flags: { reviewed: true, inCommit: true } }, + }; + }), + labelModel: { + post: async (number, labels, dryRun) => { + calls.labelPost.push({ number: number, labels: labels, dryRun: dryRun }); + if (overrides.labelPost) { + return overrides.labelPost(number); + } + return labels; + }, + }, + comment: async (number, metadata, dryRun) => { + calls.comment.push({ number: number, dryRun: dryRun }); + if (overrides.comment) { + return overrides.comment(number); + } + return true; + }, + logger: { + info: function() { calls.info.push(Array.from(arguments)); }, + error: function() { calls.error.push(Array.from(arguments)); }, + }, + }; + return { deps: deps, calls: calls }; +} + +suite('pollWebKitExports', function() { + test('labels and comments on each WebKit export, ignoring other PRs', async function() { + const { deps, calls } = fakeDeps([ + pr(1), + pr(2, 'Not a WebKit export'), + pr(3), + ]); + const failed = await pollWebKitExports(false, deps); + assert.deepEqual(failed, []); + assert.deepEqual(calls.getMetadata, [1, 3]); + assert.deepEqual(calls.labelPost.map(c => c.number), [1, 3]); + assert.deepEqual(calls.labelPost[0].labels, ['webkit-export']); + assert.deepEqual(calls.comment.map(c => c.number), [1, 3]); + assert.deepEqual(calls.error, []); + const exportLog = calls.info.find(args => args[0].webkitExport); + assert.equal(exportLog[0].webkitExport.reviewedDownstream, 'WebKit'); + assert.deepEqual(exportLog[0].webkitExport.flags, { reviewed: true, inCommit: true }); + assert.include(calls.info[calls.info.length - 1][0], + 'Checked 2 WebKit-exported pull requests; 0 failed.'); + }); + + test('passes dry-run through', async function() { + const { deps, calls } = fakeDeps([pr(1)]); + await pollWebKitExports(true, deps); + assert.equal(calls.labelPost[0].dryRun, true); + assert.equal(calls.comment[0].dryRun, true); + }); + + test('logs empty flags when the PR is not verified', async function() { + const { deps, calls } = fakeDeps([pr(1)], { + getMetadata: (number, login, title) => ({ + issue: number, title: title, labels: [], isWebKitVerified: false, + reviewedDownstream: null, webkit: { issue: '1' }, + }), + }); + await pollWebKitExports(false, deps); + const exportLog = calls.info.find(args => args[0].webkitExport); + assert.deepEqual(exportLog[0].webkitExport.flags, {}); + }); + + // Regression test: a failed bugs.webkit.org request for one PR used to be + // an unhandled rejection that crashed the process mid-poll, so that no PR + // was approved. + test('a failure on one PR does not stop the others', async function() { + const { deps, calls } = fakeDeps([pr(1), pr(2), pr(3)], { + getMetadata: (number, login, title) => { + if (number == 2) { + throw new Error('invalid json response body at https://bugs.webkit.org/rest/bug/2/history'); + } + return { issue: number, title: title, labels: [], webkit: {} }; + }, + }); + const failed = await pollWebKitExports(false, deps); + assert.deepEqual(failed, [2]); + assert.deepEqual(calls.getMetadata, [1, 2, 3]); + assert.deepEqual(calls.comment.map(c => c.number), [1, 3]); + assert.equal(calls.error.length, 1); + assert.include(calls.error[0][0].message, 'invalid json response body'); + assert.include(calls.error[0][1], '#2: Unable to check WebKit export'); + assert.include(calls.info[calls.info.length - 1][0], + 'Checked 3 WebKit-exported pull requests; 1 failed.'); + }); + + test('still comments when adding labels fails', async function() { + const { deps, calls } = fakeDeps([pr(1)], { + labelPost: () => { throw new Error('label failure'); }, + }); + const failed = await pollWebKitExports(false, deps); + assert.deepEqual(failed, []); + assert.deepEqual(calls.comment.map(c => c.number), [1]); + assert.equal(calls.error.length, 1); + assert.include(calls.error[0][1], '#1: Something went wrong while adding missing LABELS.'); + }); + + test('reports a failure to comment and continues', async function() { + const { deps, calls } = fakeDeps([pr(1), pr(2)], { + comment: (number) => { + if (number == 1) { + throw new Error('comment failure'); + } + return true; + }, + }); + const failed = await pollWebKitExports(false, deps); + assert.deepEqual(failed, [1]); + assert.deepEqual(calls.comment.map(c => c.number), [1, 2]); + assert.equal(calls.error.length, 1); + }); + + test('handles pull requests one at a time', async function() { + const { deps, calls } = fakeDeps([pr(1), pr(2), pr(3), pr(4)]); + await pollWebKitExports(false, deps); + assert.equal(calls.maxInFlight, 1); + }); + + test('rejects if the pull requests cannot be listed', async function() { + const { deps } = fakeDeps([]); + deps.github.get = async () => { throw new Error('GitHub is down'); }; + let error; + try { + await pollWebKitExports(false, deps); + } catch (e) { + error = e; + } + assert.equal(error && error.message, 'GitHub is down'); + }); +});