puppeteer/tools/bisect.ts
jrandolf 6a05d8e9c1
chore: improve docs and scripts (#9107)
This PR updates some docs and scripts related to the recent changes in
the repository.
2022-10-13 18:55:11 +02:00

320 lines
8.8 KiB
JavaScript
Executable File

#!/usr/bin/env node
/**
* Copyright 2018 Google Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import {execSync, fork, spawn} from 'child_process';
import debug from 'debug';
import fs from 'fs';
import minimist from 'minimist';
import path from 'path';
import {BrowserFetcher, BrowserFetcherRevisionInfo} from 'puppeteer';
import URL from 'url';
import ProgressBar from 'progress';
const COLOR_RESET = '\x1b[0m';
const COLOR_RED = '\x1b[31m';
const COLOR_GREEN = '\x1b[32m';
const COLOR_YELLOW = '\x1b[33m';
const argv = minimist(process.argv.slice(2), {});
const help = `
Usage:
node bisect.js --good <revision> --bad <revision> <script>
Parameters:
--good revision that is known to be GOOD, defaults to the chromium revision in src/revision.ts in the main branch
--bad revision that is known to be BAD, defaults to the chromium revision in src/revision.ts
--no-cache do not keep downloaded Chromium revisions
--unit-test pattern that identifies a unit tests that should be checked
--script path to a script that returns non-zero code for BAD revisions and 0 for good
Example:
node tools/bisect.js --unit-test test
node tools/bisect.js --good 577361 --bad 599821 --script simple.js
node tools/bisect.js --good 577361 --bad 599821 --unit-test test
`;
if (argv.h || argv.help) {
console.log(help);
process.exit(0);
}
if (typeof argv.good !== 'number') {
argv.good = getChromiumRevision('main');
if (typeof argv.good !== 'number') {
console.log(
COLOR_RED +
'ERROR: Could not parse current Chromium revision' +
COLOR_RESET
);
console.log(help);
process.exit(1);
}
}
if (typeof argv.bad !== 'number') {
argv.bad = getChromiumRevision();
if (typeof argv.bad !== 'number') {
console.log(
COLOR_RED +
'ERROR: Could not parse Chromium revision in the main branch' +
COLOR_RESET
);
console.log(help);
process.exit(1);
}
}
if (!argv.script && !argv['unit-test']) {
console.log(
COLOR_RED +
'ERROR: Expected to be given a script or a unit test to run' +
COLOR_RESET
);
console.log(help);
process.exit(1);
}
const scriptPath = argv.script && path.resolve(argv.script);
if (scriptPath && !fs.existsSync(scriptPath)) {
console.log(
COLOR_RED +
'ERROR: Expected to be given a path to a script to run' +
COLOR_RESET
);
console.log(help);
process.exit(1);
}
const browserFetcher = new BrowserFetcher();
(async (scriptPath, good, bad, pattern, noCache) => {
const span = Math.abs(good - bad);
console.log(
`Bisecting ${COLOR_YELLOW}${span}${COLOR_RESET} revisions in ${COLOR_YELLOW}~${
span.toString(2).length
}${COLOR_RESET} iterations`
);
while (true) {
const middle = Math.round((good + bad) / 2);
const revision = await findDownloadableRevision(middle, good, bad);
if (!revision || revision === good || revision === bad) {
break;
}
let info: BrowserFetcherRevisionInfo | undefined =
browserFetcher.revisionInfo(revision);
const shouldRemove = noCache && !info.local;
info = await downloadRevision(revision);
const exitCode = await (pattern
? runUnitTest(pattern, info)
: runScript(scriptPath, info));
if (shouldRemove) {
await browserFetcher.remove(revision);
}
let outcome;
if (exitCode) {
bad = revision;
outcome = COLOR_RED + 'BAD' + COLOR_RESET;
} else {
good = revision;
outcome = COLOR_GREEN + 'GOOD' + COLOR_RESET;
}
const span = Math.abs(good - bad);
let fromText = '';
let toText = '';
if (good < bad) {
fromText = COLOR_GREEN + good + COLOR_RESET;
toText = COLOR_RED + bad + COLOR_RESET;
} else {
fromText = COLOR_RED + bad + COLOR_RESET;
toText = COLOR_GREEN + good + COLOR_RESET;
}
console.log(
`- ${COLOR_YELLOW}r${revision}${COLOR_RESET} was ${outcome}. Bisecting [${fromText}, ${toText}] - ${COLOR_YELLOW}${span}${COLOR_RESET} revisions and ${COLOR_YELLOW}~${
span.toString(2).length
}${COLOR_RESET} iterations`
);
}
const [fromSha, toSha] = await Promise.all([
revisionToSha(Math.min(good, bad)),
revisionToSha(Math.max(good, bad)),
]);
console.log(
`RANGE: https://chromium.googlesource.com/chromium/src/+log/${fromSha}..${toSha}`
);
})(scriptPath, argv.good, argv.bad, argv['unit-test'], argv['no-cache']);
function runScript(scriptPath, revisionInfo) {
const log = debug('bisect:runscript');
log('Running script');
const child = fork(scriptPath, [], {
stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
env: {
...process.env,
PUPPETEER_EXECUTABLE_PATH: revisionInfo.executablePath,
},
});
return new Promise((resolve, reject) => {
child.on('error', err => {
return reject(err);
});
child.on('exit', code => {
return resolve(code);
});
});
}
function runUnitTest(pattern, revisionInfo) {
const log = debug('bisect:rununittest');
log('Running unit test');
const child = spawn('npm run test:chrome:headless', ['--', '-g', pattern], {
stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
shell: true,
env: {
...process.env,
PUPPETEER_EXECUTABLE_PATH: revisionInfo.executablePath,
},
});
return new Promise((resolve, reject) => {
child.on('error', err => {
return reject(err);
});
child.on('exit', code => {
return resolve(code);
});
});
}
async function downloadRevision(revision) {
const log = debug('bisect:download');
log(`Downloading ${revision}`);
let progressBar: ProgressBar | undefined;
let lastDownloadedBytes = 0;
return await browserFetcher.download(
revision,
(downloadedBytes, totalBytes) => {
if (!progressBar) {
progressBar = new ProgressBar(
`- downloading Chromium r${revision} - ${toMegabytes(
totalBytes
)} [:bar] :percent :etas `,
{
complete: '=',
incomplete: ' ',
width: 20,
total: totalBytes,
}
);
}
const delta = downloadedBytes - lastDownloadedBytes;
lastDownloadedBytes = downloadedBytes;
progressBar.tick(delta);
}
);
function toMegabytes(bytes) {
const mb = bytes / 1024 / 1024;
return `${Math.round(mb * 10) / 10} Mb`;
}
}
async function findDownloadableRevision(rev, from, to) {
const log = debug('bisect:findrev');
const min = Math.min(from, to);
const max = Math.max(from, to);
log(`Looking around ${rev} from [${min}, ${max}]`);
if (await browserFetcher.canDownload(rev)) {
return rev;
}
let down = rev;
let up = rev;
while (min <= down || up <= max) {
const [downOk, upOk] = await Promise.all([
down > min ? probe(--down) : Promise.resolve(false),
up < max ? probe(++up) : Promise.resolve(false),
]);
if (downOk) {
return down;
}
if (upOk) {
return up;
}
}
return null;
async function probe(rev) {
const result = await browserFetcher.canDownload(rev);
log(` ${rev} - ${result ? 'OK' : 'missing'}`);
return result;
}
}
async function revisionToSha(revision) {
const json = await fetchJSON(
'https://cr-rev.appspot.com/_ah/api/crrev/v1/redirect/' + revision
);
return json.git_sha;
}
async function fetchJSON(url: string): Promise<{git_sha: string}> {
const agent = url.startsWith('https://')
? await import('https')
: await import('http');
return new Promise((resolve, reject) => {
const options = {
...URL.parse(url),
method: 'GET',
headers: {
'Content-Type': 'application/json',
},
};
const req = agent.request(options, function (res) {
let result = '';
res.setEncoding('utf8');
res.on('data', chunk => {
return (result += chunk);
});
res.on('end', () => {
return resolve(JSON.parse(result));
});
});
req.on('error', err => {
return reject(err);
});
req.end();
});
}
function getChromiumRevision(gitRevision?: string) {
const fileName = 'packages/puppeteer-core/src/revisions.ts';
const command = gitRevision
? `git show ${gitRevision}:${fileName}`
: `cat ${fileName}`;
const result = execSync(command, {
encoding: 'utf8',
});
const m = result.match(/chromium: '(\d+)'/);
if (!m) {
return null;
}
return parseInt(m[1], 10);
}