ncu-ci

#!/usr/bin/env node

'use strict';

const {
  JobParser,
  parseJobFromURL,
  CI_TYPES_KEYS: {
    PR, COMMIT, BENCHMARK
  }
} = require('../lib/ci/ci_type_parser');

const {
  PRBuild, BenchmarkRun, CommitBuild, listBuilds, FailureAggregator
  // , jobCache
} = require('../lib/ci/ci_result_parser');
const clipboardy = require('clipboardy');
const { writeJson } = require('../lib/file');

const { runPromise } = require('../lib/run');
const auth = require('../lib/auth');
const Request = require('../lib/request');
const CLI = require('../lib/cli');
const yargs = require('yargs');

// This is used for testing
// Default cache dir is ${ncu-source-dir}/.ncu/cache
// jobCache.enable();

// eslint-disable-next-line no-unused-vars
const argv = yargs
  .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,
          describe: 'Aggregate the results'
        })
        .option('limit', {
          default: 99,
          describe: 'Maximum number of CIs to get data from'
        });
    },
    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 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
  })
  .demandCommand(1, 'must provide a valid command')
  .option('copy', {
    default: false,
    describe: 'Write the results as markdown to clipboard'
  })
  .option('json', {
    type: 'string',
    describe: 'Write the results as json to the path'
  })
  .help()
  .argv;

async function getResults(cli, request, job) {
  let build;
  const { type, jobid } = job;
  if (type === PR) {
    build = new PRBuild(cli, request, jobid);
    await build.getResults();
  } else if (type === COMMIT) {
    build = new CommitBuild(cli, request, jobid);
    await build.getResults();
  } else if (type === BENCHMARK) {
    build = new BenchmarkRun(cli, request, jobid);
    await build.getResults();
  } else {
    yargs.showHelp();
    return;
  }
  return build;
}

async function runQueue(queue, cli, request, argv) {
  let dataToCopy = '';
  let dataToJson = [];

  for (let job of queue) {
    cli.separator('');
    if (job.link) {
      cli.log(`Running ${job.link}`);
    } else {
      cli.log(`Running ${job.type}: ${job.jobid}`);
    }
    cli.separator('');
    const build = await getResults(cli, request, job);
    build.display();

    if (argv.copy) {
      dataToCopy += build.formatAsMarkdown();
    }

    dataToJson = dataToJson.concat(build.formatAsJson());
  }

  return {
    json: dataToJson,
    copy: dataToCopy
  };
}

function pad(any, length) {
  return (any + '').padEnd(length);
}

// Produces a row for https://github.com/nodejs/reliability#ci-health-history
function displayHealth(builds, cli) {
  const [
    count, success, pending, aborted, failed, unstable
  ] = [
    builds.count, builds.success.length, builds.pending.length,
    builds.aborted.length, builds.failed.length, builds.unstable.length
  ];
  const rate = `${(success / (count - pending - aborted) * 100).toFixed(2)}%`;
  // eslint-disable-next-line max-len
  cli.log('| UTC Time         | RUNNING | SUCCESS | UNSTABLE | ABORTED | FAILURE | Green Rate |');
  // eslint-disable-next-line max-len
  cli.log('| ---------------- | ------- | ------- | -------- | ------- | ------- | ---------- |');
  const time = new Date().toISOString().slice(0, 16).replace('T', ' ');
  let result = `| ${time} | ${pad(pending, 7)} | ${pad(success, 8)}|`;
  result += ` ${pad(unstable, 8)} | ${pad(aborted, 7)} | ${pad(failed, 7)} |`;
  result += ` ${pad(rate, 10)} |`;
  cli.log(result);
}

async function main(command, argv) {
  const cli = new CLI();
  const credentials = await auth({
    github: true,
    jenkins: true
  });
  const request = new Request(credentials);
  const queue = [];

  const commandToType = {
    'commit': COMMIT,
    'pr': PR,
    'benchmark': BENCHMARK
  };

  if (command === 'rate' || command === 'walk') {
    const type = commandToType[argv.type];
    const builds = await listBuilds(cli, request, type);
    if (command === 'walk') {
      for (const build of builds.failed.slice(0, argv.limit)) {
        queue.push(build);
      }
    } else {
      displayHealth(builds, cli);
    }
  }

  if (command === 'url') {
    let parsed = parseJobFromURL(argv.url);
    if (parsed) {
      queue.push({
        type: parsed.type,
        jobid: parsed.jobid
      });
    } else {
      const parser = await JobParser.fromPR(argv.url, cli, request);
      if (!parser) {  // Not a valid PR URL
        return yargs.showHelp();
      }
      const ciMap = parser.parse();
      for (const [type, ci] of ciMap) {
        queue.push({
          type: type,
          jobid: ci.jobid
        });
      }
    }
  } else if (commandToType[command]) {
    queue.push({
      type: commandToType[command],
      jobid: argv.jobid
    });
  }

  if (queue.length > 0) {
    const data = await runQueue(queue, cli, request, argv);

    if (command === 'walk' && argv.stats) {
      const aggregator = new FailureAggregator(cli, data.json);
      data.json = aggregator.aggregate();
      cli.log('');
      cli.separator('Stats');
      cli.log('');
      aggregator.display();
      if (argv.copy) {
        data.copy = aggregator.formatAsMarkdown();
      }
    }

    if (argv.copy) {
      clipboardy.writeSync(data.copy);
      cli.separator('');
      cli.log(`Written markdown to clipboard`);
    }

    if (argv.json) {
      writeJson(argv.json, data.json);
      cli.separator('');
      cli.log(`Written JSON to ${argv.json}`);
    }
  }
}

function handler(argv) {
  const [ command ] = argv._;
  runPromise(main(command, argv));
}