Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
38 changes: 3 additions & 35 deletions index.js
Original file line number Diff line number Diff line change
Expand Up @@ -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();
Expand Down Expand Up @@ -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.
Expand Down
84 changes: 84 additions & 0 deletions lib/webkit-poller.js
Original file line number Diff line number Diff line change
@@ -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<number[]>} 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;
};
189 changes: 189 additions & 0 deletions test/webkit-poller.js
Original file line number Diff line number Diff line change
@@ -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');
});
});
Loading