#!/usr/bin/env node

import yargs from 'yargs';

import clipboardy from 'clipboardy';

import {

JobParser,

parseJobFromURL,

CI_TYPES_KEYS

} from '../lib/ci/ci_type_parser.js';

import { setVerbosityFromEnv } from '../lib/verbosity.js';

import { listBuilds } from '../lib/ci/ci_utils.js';

import { jobCache } from '../lib/ci/build-types/job.js';

import { PRBuild } from '../lib/ci/build-types/pr_build.js';

import { CommitBuild } from '../lib/ci/build-types/commit_build.js';

import { DailyBuild } from '../lib/ci/build-types/daily_build.js';

import { FailureAggregator } from '../lib/ci/failure_aggregator.js';

import { BenchmarkRun } from '../lib/ci/build-types/benchmark_run.js';

import { HealthBuild } from '../lib/ci/build-types/health_build.js';

import { CITGMBuild } from '../lib/ci/build-types/citgm_build.js';

import {

CITGMComparisonBuild

} from '../lib/ci/build-types/citgm_comparison_build.js';

import {

RunPRJob

} from '../lib/ci/run_ci.js';

import { writeJson, writeFile } from '../lib/file.js';

import { getMergedConfig } from '../lib/config.js';

import { runPromise } from '../lib/run.js';

import auth from '../lib/auth.js';

import Request from '../lib/request.js';

import CLI from '../lib/cli.js';

import { hideBin } from 'yargs/helpers';

setVerbosityFromEnv();

const {

PR,

COMMIT,

BENCHMARK,

CITGM,

CITGM_NOBUILD,

DAILY_MASTER

} = CI_TYPES_KEYS;

const commandKeys = [

'rate',

'walk',

'url',

'pr',

'commit',

'citgm'

];

const args = yargs(hideBin(process.argv))

.completion('completion')

.command({

command: 'rate <type>',

desc: 'Calculate the green rate of a CI job in the last 100 runs',

builder: (yargs) => {

yargs

.positional('type', {

describe: 'type of CI',

choices: ['commit', 'pr']

});

},

handler

})

.command({

command: 'walk <type>',

desc: 'Walk the CI and display the failures',

builder: (yargs) => {

yargs

.positional('type', {

describe: 'type of CI',

choices: ['commit', 'pr']

})

.option('stats', {

default: false,

type: 'boolean',

describe: 'Aggregate the results'

})

.option('cache', {

default: false,

type: 'boolean',

describe: 'Cache the responses from Jenkins in $tmpdir/ncu/cache for testing'

})

.option('limit', {

default: 99,

describe: 'Maximum number of CIs to get data from'

})

.option('since <date>', {

type: 'string',

describe: 'Time since when the CI results should be queried'

}).check(argv => {

try {

// eslint-disable-next-line no-new

new Date(argv.since);

} catch {

throw new Error('--since <date> should be string that can ' +

'be parsed by new Date()');

}

return true;

});

},

handler

})

.command({

command: 'run <prid>',

desc: 'Run CI for given PR',

builder: (yargs) => {

yargs

.positional('prid', {

describe: 'ID of the PR or URL to the PR or its head commit',

type: 'string'

})

.option('certify-safe', {

describe: 'SHA of the commit that is expected to be at the tip of the PR head. ' +

'If not provided, the command will use the SHA of the last approved commit.',

type: 'string'

})

.option('check-for-duplicates', {

describe: 'When set, NCU will query Jenkins recent builds to ensure ' +

'there is not an existing job for the same commit.',

type: 'boolean'

})

.option('owner', {

default: '',

describe: 'GitHub repository owner'

})

.option('repo', {

default: '',

describe: 'GitHub repository name'

});

},

handler

})

.command({

command: 'url <url>',

desc: 'Automatically detect CI type and show results',

builder: (yargs) => {

yargs

.positional('url', {

describe: 'URL of the PR or the CI',

type: 'string'

});

},

handler

})

.command({

command: 'pr <jobid>',

desc: 'Show results of a node-test-pull-request CI job',

builder: (yargs) => {

yargs

.positional('jobid', {

describe: 'id of the job',

type: 'number'

});

},

handler

})

.command({

command: 'commit <jobid>',

desc: 'Show results of a node-test-commit CI job',

builder: (yargs) => {

yargs

.positional('jobid', {

describe: 'id of the first job',

type: 'number'

});

},

handler

})

.command({

command: 'benchmark <jobid>',

desc: 'Show results of a benchmark-node-micro-benchmarks CI job',

builder: (yargs) => {

yargs

.positional('jobid', {

describe: 'id of the job',

type: 'number'

});

},

handler

})

.command({

command: 'citgm <jobid> [jobid2]',

desc: 'Show results of a citgm-smoker CI job',

builder: (yargs) => {

yargs

.positional('jobid', {

describe: 'id of the job',

type: 'number'

})

.positional('jobid2', {

describe: 'id of the second job, if doing a comparison',

type: 'number'

});

},

handler

})

.command({

command: 'daily',

desc: 'Show recent results of node-daily-master',

builder: (yargs) => {

yargs

.option('stats', {

type: 'boolean',

default: false,

describe: 'Aggregate the results'

})

.option('cache', {

type: 'boolean',

default: false,

describe: 'Cache the responses from Jenkins in $tmpdir/ncu/cache for testing'

})

.option('limit', {

default: 15,

describe: 'Maximum number of CIs to get data from'

});

},

handler

})

.demandCommand(1, 'must provide a valid command')

.option('copy', {

describe: 'Write the results as markdown to clipboard',

default: false,

type: 'boolean'

})

.option('skip-more-than', {

describe: 'Skip jobs that fail more than <limit> builds, when --stat is true, default to 10.',

type: 'number',

default: Infinity

})

.option('nobuild', {

describe: 'If running cigtm, whether or not jobid is citgm-nobuild.',

type: 'boolean',

default: false

})

.option('json <path>', {

type: 'string',

describe: 'Write the results as json to <path>'

})

.option('markdown <path>', {

type: 'string',

describe: 'Write the results as markdown to <path>'

}).check(argv => {

if (argv.markdown && commandKeys.includes(argv.markdown)) {

throw new Error('--markdown <path> did not specify a valid path');

} else if (argv.json && commandKeys.includes(argv.json)) {

throw new Error('--json <path> did not specify a valid path');

}

return true;

})

.help();

args.parse();

const commandToType = {

commit: COMMIT,

pr: PR,

benchmark: BENCHMARK,

citgm: CITGM

};

class RunPRJobCommand {

constructor(cli, request, argv) {

this.cli = cli;

this.request = request;

this.dir = process.cwd();

this.argv = argv;

this.config = getMergedConfig(this.dir);

}

get owner() {

return this.argv.owner || this.config.owner;

}

get repo() {

return this.argv.repo || this.config.repo;

}

get prid() {

return this.argv.prid;

}

async start() {

const {

cli, request, prid, repo, owner

} = this;

let validArgs = true;

if (!repo) {

validArgs = false;

cli.error('GitHub repository is missing, please set it via ncu-config ' +

'or pass it via the --repo option');

}

if (!owner) {

cli.error('GitHub owner is missing, please set it via ncu-config ' +

'or pass it via the --owner option');

validArgs = false;

}

if (!validArgs) {

this.cli.setExitCode(1);

return;

}

const { certifySafe, checkForDuplicates } = this.argv;

const jobRunner = new RunPRJob(

cli, request, owner, repo, prid,

certifySafe, checkForDuplicates);

if (!(await jobRunner.start())) {

this.cli.setExitCode(1);

process.exitCode = 1;

}

}

}

class CICommand {

constructor(cli, request, argv) {

this.cli = cli;

this.request = request;

this.argv = argv;

this.queue = [];

this.json = [];

this.markdown = '';

}

async drain() {

if (this.queue.length === 0) {

return;

}

const { cli, queue, argv, request } = this;

for (let i = 0; i < queue.length; ++i) {

const job = queue[i];

cli.separator('');

const progress = `[${i + 1}/${queue.length}]`;

if (job.link) {

cli.log(`${progress} Running ${job.link}`);

} else if (job.jobid) {

cli.log(`${progress} Running ${job.type}: ${job.jobid}`);

} else {

cli.log(`${progress} Running ${job.type}`);

}

cli.separator('');

let build;

let { skipMoreThan } = argv;

if (argv.stats && argv.skipMoreThan === Infinity) {

skipMoreThan = 10;

}

switch (job.type) {

case 'health':

build = new HealthBuild(cli, request, job.ciType, job.builds);

break;

case PR:

build = new PRBuild(cli, request, job.jobid, skipMoreThan);

break;

case COMMIT:

build = new CommitBuild(cli, request, job.jobid, skipMoreThan);

break;

case CITGM:

case CITGM_NOBUILD:

if (job.jobid2) {

build = new CITGMComparisonBuild(cli, request, job);

} else {

build = new CITGMBuild(cli, request, job);

}

break;

case BENCHMARK:

build = new BenchmarkRun(cli, request, job.jobid);

break;

case DAILY_MASTER: {

const daily = new DailyBuild(cli, request, job.jobid);

const data = await daily.getBuildData();

const testCommitBuild = data.subBuilds.filter(subBuild => {

return subBuild.jobName === 'node-test-commit';

})[0];

if (testCommitBuild) {

build = new CommitBuild(cli, request, testCommitBuild.buildNumber);

break;

} else {

throw new Error('Could not find \'node-test-commit\' job');

}

}

default:

throw new Error(`Unknown job type ${job.type}`);

}

await build.getResults();

build.display();

// Set this.json regardless of whether the user has passed

// --json - it's needed for failure aggregation.

const json = build.formatAsJson();

if (json !== undefined) {

this.json = this.json.concat(json);

}

if ((argv.copy || argv.markdown) && !argv.stats) {

this.markdown += build.formatAsMarkdown();

}

}

}

async aggregate() {} // noop

async serialize() {

const { argv, cli } = this;

if (argv.copy) {

if (this.markdown) {

clipboardy.writeSync(this.markdown);

cli.separator('');

cli.log('Written markdown to clipboard');

} else {

cli.error('No markdown generated');

}

}

if (argv.markdown) {

if (this.markdown) {

writeFile(argv.markdown, this.markdown);

cli.separator('');

cli.log(`Written markdown to ${argv.markdown}`);

} else {

cli.error('No markdown generated');

}

}

if (argv.json) {

if (this.json.length) {

writeJson(argv.json, this.json);

cli.separator('');

cli.log(`Wrote JSON to ${argv.json}`);

} else {

cli.error('No JSON generated');

}

}

}

}

class RateCommand extends CICommand {

async initialize() {

this.queue.push({

type: 'health',

ciType: commandToType[this.argv.type]

});

}

}

class WalkCommand extends CICommand {

constructor(cli, request, argv) {

super(cli, request, argv);

if (argv.cache) {

jobCache.enable();

}

}

async initialize() {

const ciType = commandToType[this.argv.type];

const since = this.argv.since ? new Date(this.argv.since) : undefined;

const builds = await listBuilds(this.cli, this.request, ciType, since);

if (builds.count === 0) {

this.cli.log('No applicable builds found.');

return;

}

this.queue.push({ type: 'health', ciType, builds });

for (const build of builds.failed.slice(0, this.argv.limit)) {

this.queue.push(build);

}

}

async aggregate() {

const { argv, cli } = this;

if (this.queue.length === 0) {

return;

}

const aggregator = new FailureAggregator(cli, this.json);

this.json = aggregator.aggregate();

cli.log('');

cli.separator('Stats');

cli.log('');

aggregator.display();

if (argv.markdown || argv.copy) {

this.markdown = aggregator.formatAsMarkdown();

}

}

}

class JobCommand extends CICommand {

constructor(cli, request, argv, command) {

super(cli, request, argv);

this.command = command;

}

async initialize() {

const { queue, argv } = this;

queue.push({

type: commandToType[this.command],

jobid: argv.jobid,

jobid2: argv.jobid2,

noBuild: this.argv.nobuild

});

}

}

class URLCommand extends CICommand {

async initialize() {

const { argv, cli, request, queue } = this;

const parsed = parseJobFromURL(argv.url);

if (parsed) {

queue.push({

type: parsed.type,

jobid: parsed.jobid

});

return;

}

// Parse CI links from PR.

const parser = await JobParser.fromPR(argv.url, cli, request);

if (!parser) { // Not a valid PR URL

cli.error(`${argv.url} is not a valid PR URL`);

return;

}

const ciMap = parser.parse();

if (ciMap.size === 0) {

cli.info(`No CI run detected from ${argv.url}`);

}

for (const [type, ci] of ciMap) {

queue.push({

type,

jobid: ci.jobid

});

}

}

}

class DailyCommand extends CICommand {

constructor(cli, request, argv) {

super(cli, request, argv);

if (argv.cache) {

jobCache.enable();

}

}

async initialize() {

const ciType = DAILY_MASTER;

const builds = await listBuilds(this.cli, this.request, ciType);

this.queue.push({ type: 'health', ciType, builds });

for (const build of builds.failed.slice(0, this.argv.limit)) {

this.queue.push(build);

}

}

async aggregate() {

const { argv, cli } = this;

const aggregator = new FailureAggregator(cli, this.json);

this.json = aggregator.aggregate();

cli.log('');

cli.separator('Stats');

cli.log('');

aggregator.display();

if (argv.markdown || argv.copy) {

this.markdown = aggregator.formatAsMarkdown();

}

}

}

async function main(command, argv) {

const cli = new CLI();

const credentials = await auth({

github: true,

jenkins: true

});

const request = new Request(credentials);

let commandHandler;

// Prepare queue.

switch (command) {

case 'run': {

const maybeURL = URL.parse(argv.prid);

if (maybeURL?.host === 'github.com') {

const [, owner, repo, , prid, , commit_sha] = maybeURL.pathname.split('/');

argv.owner ||= owner;

argv.repo ||= repo;

argv.certifySafe ||= commit_sha;

argv.prid = prid;

}

argv.prid = Number(argv.prid);

const jobRunner = new RunPRJobCommand(cli, request, argv);

return jobRunner.start();

}

case 'rate': {

commandHandler = new RateCommand(cli, request, argv);

break;

}

case 'walk': {

commandHandler = new WalkCommand(cli, request, argv);

break;

}

case 'url': {

commandHandler = new URLCommand(cli, request, argv);

break;

}

case 'pr':

case 'commit':

case 'citgm':

case 'benchmark': {

commandHandler = new JobCommand(cli, request, argv, command);

break;

}

case 'daily': {

commandHandler = new DailyCommand(cli, request, argv, command);

break;

}

default:

return args.showHelp();

}

await commandHandler.initialize();

await commandHandler.drain();

await commandHandler.aggregate();

await commandHandler.serialize();

}

function handler(argv) {

const [command] = argv._;

runPromise(main(command, argv));

}