@node-core/utils 4.0.0

package/lib/ci/build-types/health_build.js

@@ -0,0 +1,63 @@
+import { listBuilds, pad } from '../ci_utils.js';
+
+const kHealthKeys = [
+  'success',
+  'pending',
+  'aborted',
+  'failed',
+  'unstable'
+];
+
+class Health {
+  constructor(builds) {
+    for (const key of kHealthKeys) {
+      this[key] = builds[key].length;
+      this.count = builds.count;
+    }
+  }
+
+  // Produces a row for https://github.com/nodejs/reliability#ci-health-history
+  formatAsMarkdown() {
+    const { success, pending, aborted, failed, unstable, count } = this;
+    const rate = `${(success / (count - pending - aborted) * 100).toFixed(2)}%`;
+    // eslint-disable-next-line max-len
+    let result = '| UTC Time         | RUNNING | SUCCESS | UNSTABLE | ABORTED | FAILURE | Green Rate |\n';
+    // eslint-disable-next-line max-len
+    result += '| ---------------- | ------- | ------- | -------- | ------- | ------- | ---------- |\n';
+    const time = new Date().toISOString().slice(0, 16).replace('T', ' ');
+    result += `| ${time} | ${pad(pending, 7)} | ${pad(success, 8)}|`;
+    result += ` ${pad(unstable, 8)} | ${pad(aborted, 7)} | ${pad(failed, 7)} |`;
+    result += ` ${pad(rate, 10)} |\n`;
+    return result;
+  }
+}
+
+export class HealthBuild {
+  constructor(cli, request, ciType, builds) {
+    this.cli = cli;
+    this.request = request;
+    this.type = 'health';
+    this.ciType = ciType;
+    this.builds = builds;
+    this.name = 'health';
+  }
+
+  async getResults() {
+    if (!this.builds) {
+      this.builds = await listBuilds(this.cli, this.request, this.ciType);
+    }
+    this.health = new Health(this.builds);
+  }
+
+  formatAsJson() {
+    return this.health;
+  }
+
+  formatAsMarkdown() {
+    return this.health.formatAsMarkdown();
+  }
+
+  display() {
+    this.cli.log(this.formatAsMarkdown());
+  }
+}

package/lib/ci/build-types/job.js

@@ -0,0 +1,114 @@
+import qs from 'node:querystring';
+
+import { CI_DOMAIN } from '../ci_type_parser.js';
+import Cache from '../../cache.js';
+import CIFailureParser from '../ci_failure_parser.js';
+
+const {
+  FAILURE_TYPES: { NCU_FAILURE },
+  FAILURE_CONSTRUCTORS: {
+    [NCU_FAILURE]: NCUFailure
+  },
+  CIResult
+} = CIFailureParser;
+
+export class Job {
+  constructor(cli, request, path, tree) {
+    this.cli = cli;
+    this.request = request;
+    this.path = path;
+    this.tree = tree;
+  }
+
+  get jobUrl() {
+    const { path } = this;
+    return `https://${CI_DOMAIN}/${path}`;
+  }
+
+  get apiUrl() {
+    const { tree, jobUrl } = this;
+    const query = tree ? `?tree=${qs.escape(tree)}` : '';
+    return `${jobUrl}api/json${query}`;
+  }
+
+  get consoleUrl() {
+    const { path } = this;
+    return `https://${CI_DOMAIN}/${path}consoleText`;
+  }
+
+  get consoleUIUrl() {
+    const { path } = this;
+    return `https://${CI_DOMAIN}/${path}console`;
+  }
+
+  async getBuildData(type = 'Build') {
+    const { cli, path } = this;
+    cli.startSpinner(`Querying data for ${path}`);
+    const data = await this.getAPIData();
+    cli.stopSpinner(`${type} data downloaded`);
+    return data;
+  }
+
+  getCause(actions) {
+    if (actions && actions.find(item => item.causes)) {
+      const action = actions.find(item => item.causes);
+      return action.causes[0];
+    }
+  }
+
+  async getAPIData() {
+    const { apiUrl, cli, request, path } = this;
+    cli.updateSpinner(`Querying API for ${path}`);
+    return request.json(apiUrl);
+  }
+
+  async getConsoleText() {
+    const { cli, consoleUrl, request, path } = this;
+    cli.updateSpinner(`Querying console text for ${path}`);
+    const data = await request.text(consoleUrl);
+    return data.replace(/\r/g, '');
+  }
+
+  getCacheKey() {
+    return this.path
+      .replace(/job\//, '')
+      .replace(/\//g, '-')
+      .replace(/-$/, '');
+  }
+
+  async parseConsoleText() {
+    let text;
+    try {
+      text = await this.getConsoleText();
+    } catch (err) {
+      this.failures = [
+        new NCUFailure({
+          url: this.consoleUrl, builtOn: this.builtOn
+        }, err.message)
+      ];
+      return this.failures;
+    }
+
+    const parser = new CIFailureParser(this, text);
+    let results = parser.parse();
+    if (!results) {
+      results = [
+        new CIResult({ url: this.jobUrl, builtOn: this.builtOn }, 'Unknown')
+      ];
+    }
+
+    this.failures = results;
+    return results;
+  }
+}
+
+// TODO(joyeecheung): do not cache pending jobs
+export const jobCache = new Cache();
+jobCache.wrap(Job, {
+  getConsoleText() {
+    return { key: this.getCacheKey(), ext: '.txt' };
+  },
+  getAPIData() {
+    return { key: this.getCacheKey(), ext: '.json' };
+  }
+});

package/lib/ci/build-types/linter_build.js

@@ -0,0 +1,35 @@
+import { LINTER_TREE } from '../jenkins_constants.js';
+import CIFailureParser from '../ci_failure_parser.js';
+import { Job } from './job.js';
+
+const {
+  FAILURE_TYPES: { NCU_FAILURE },
+  FAILURE_CONSTRUCTORS: {
+    [NCU_FAILURE]: NCUFailure
+  }
+} = CIFailureParser;
+
+export class LinterBuild extends Job {
+  constructor(cli, request, jobName, id) {
+    const path = `job/${jobName}/${id}/`;
+    const tree = LINTER_TREE;
+    super(cli, request, path, tree);
+
+    this.failures = [];
+    this.builtOn = undefined;
+  }
+
+  async getResults() {
+    let data;
+    try {
+      data = await this.getAPIData();
+    } catch (err) {
+      this.failures = [
+        new NCUFailure(this, err.message)
+      ];
+      return this.failures;
+    }
+    this.builtOn = data.builtOn;
+    return this.parseConsoleText();
+  }
+}

package/lib/ci/build-types/normal_build.js

@@ -0,0 +1,89 @@
+import { statusType } from '../ci_utils.js';
+import { flatten } from '../../utils.js';
+import { BUILD_TREE } from '../jenkins_constants.js';
+import CIFailureParser from '../ci_failure_parser.js';
+import { Job } from './job.js';
+import { TestRun } from './test_run.js';
+
+const {
+  FAILURE_TYPES: {
+    BUILD_FAILURE,
+    NCU_FAILURE
+  },
+  FAILURE_CONSTRUCTORS: {
+    [BUILD_FAILURE]: BuildFailure,
+    [NCU_FAILURE]: NCUFailure
+  }
+} = CIFailureParser;
+
+export class NormalBuild extends Job {
+  constructor(cli, request, jobName, id) {
+    const path = `job/${jobName}/${id}/`;
+    const tree = BUILD_TREE;
+    super(cli, request, path, tree);
+
+    this.failures = [];
+    this.builtOn = undefined;
+  }
+
+  async getResults() {
+    const { cli, request } = this;
+
+    let data;
+    try {
+      data = await this.getAPIData();
+    } catch (err) {
+      this.failures = [
+        new NCUFailure({ url: this.apiUrl }, err.message)
+      ];
+      return this.failures;
+    }
+
+    const { result, runs, builtOn } = data;
+    this.builtOn = builtOn;
+
+    if (result !== statusType.FAILURE) {
+      this.failures = [];
+      return this.failures;
+    }
+
+    if (!runs) return [];
+
+    if (!runs.length) {
+      this.failures = [
+        new BuildFailure(
+          { url: this.jobUrl, builtOn }, 'Failed to trigger runs'
+        )
+      ];
+      return this.failures;
+    }
+
+    const failed = runs.filter(run => {
+      return run.result === statusType.FAILURE;
+    });
+
+    if (!failed.length) {
+      return this.parseConsoleText();
+    }
+
+    const tests = failed.map(({ url }) => new TestRun(cli, request, url));
+
+    // Skip runs that are not actually triggered by this job
+    await Promise.all(tests.map(run => run.getData()));
+    const causes = tests.map(run => run.cause);
+    const actualRuns = tests.filter((_, index) => {
+      const upstream = causes[index].upstreamBuild;
+      if (!upstream) {
+        return true;
+      } else {
+        return this.jobUrl.includes(upstream + '');
+      }
+    });
+
+    const failures = await Promise.all(
+      actualRuns.map(run => run.getResults())
+    );
+    this.failures = flatten(failures);
+    return this.failures;
+  }
+}

package/lib/ci/build-types/pr_build.js

@@ -0,0 +1,101 @@
+import { PR_TREE } from '../jenkins_constants.js';
+import CIFailureParser from '../ci_failure_parser.js';
+import { TestBuild } from './test_build.js';
+import { CommitBuild } from './commit_build.js';
+
+const {
+  FAILURE_TYPES: {
+    BUILD_FAILURE,
+    NCU_FAILURE
+  },
+  FAILURE_CONSTRUCTORS: {
+    [BUILD_FAILURE]: BuildFailure,
+    [NCU_FAILURE]: NCUFailure
+  }
+} = CIFailureParser;
+
+export class PRBuild extends TestBuild {
+  constructor(cli, request, id) {
+    const path = `job/node-test-pull-request/${id}/`;
+    const tree = PR_TREE;
+    super(cli, request, path, tree);
+
+    this.commitBuild = null;
+  }
+
+  // Get the failures and their reasons of this build
+  async getResults() {
+    const { cli, request } = this;
+
+    let data;
+    try {
+      data = await this.getBuildData();
+    } catch (err) {
+      this.failures = [
+        new NCUFailure({ url: this.apiUrl }, err.message)
+      ];
+      return this.failures;
+    }
+    const {
+      result, subBuilds, changeSet, actions, timestamp
+    } = data;
+
+    // No builds found.
+    if (data.status === '404') {
+      const failure = new BuildFailure(this, 'No builds found for PR');
+      this.failures = [failure];
+      return {
+        result: data.result,
+        builds: { failed: [], aborted: [], pending: [], unstable: [] },
+        failures: this.failures
+      };
+    }
+
+    this.setBuildData(data);
+
+    // No sub build at all
+    const commitBuild = subBuilds[0];
+    if (!commitBuild) {
+      const failure = new BuildFailure(
+        this, 'Failed to trigger node-test-commit'
+      );
+      Object.assign(failure, {
+        source: this.sourceURL,
+        upstream: this.jobUrl,
+        builtOn: this.builtOn
+      });
+      this.failures = [failure];
+      return { result, builds: {}, failures: this.failures };
+    }
+
+    // Get result from the sub build
+    // assert.strictEqual(commitBuild.jobName, 'node-test-commit');
+    const allBuilds = commitBuild.build.subBuilds;
+    // TODO: fetch result, builtOn, timestamp in the commit build's own data
+    // ..or maybe they do not worth an additional API call?
+    // Note that we have to pass the actions down to detect resume builds.
+    const buildData = {
+      result, subBuilds: allBuilds, changeSet, actions, timestamp
+    };
+    const commitBuildId = commitBuild.buildNumber;
+    this.commitBuild = new CommitBuild(cli, request, commitBuildId);
+    const { builds, failures } = await this.commitBuild.getResults(buildData);
+
+    // Set up aliases for display
+    this.builds = builds;
+    this.failures = failures;
+    return { result, builds, failures };
+  }
+
+  formatAsMarkdown() {
+    if (!this.commitBuild) {
+      let result = 'Failed to trigger node-test-commit';
+      if (this.builtOn) {
+        result += ` on ${this.builtOn}`;
+      }
+      result += `\n\nURL: ${this.jobUrl}`;
+      return result;
+    }
+    return super.formatAsMarkdown();
+  }
+}

package/lib/ci/build-types/test_build.js

@@ -0,0 +1,186 @@
+import chalk from 'chalk';
+
+import { shortSha } from '../../utils.js';
+import {
+  fold,
+  getNodeName,
+  statusType
+} from '../ci_utils.js';
+import { CI_DOMAIN } from '../ci_type_parser.js';
+import { Job } from './job.js';
+
+const resultName = (result) => {
+  return result === null ? 'PENDING' : result.toUpperCase();
+};
+
+const getUrl = (path) => {
+  const urlPath = path.replace(`https://${CI_DOMAIN}/`, '').replace('api/json', '');
+  return `https://${CI_DOMAIN}/${urlPath}`;
+};
+
+export class TestBuild extends Job {
+  constructor(cli, request, path, tree) {
+    super(cli, request, path, tree);
+
+    // Should be assigned in getResults()
+    this.result = null;
+    this.params = {};
+    this.change = {};
+    this.date = undefined;
+    this.builds = {
+      failed: [], aborted: [], pending: [], unstable: []
+    };
+    this.failures = [];
+    this.builtOn = undefined;
+  }
+
+  setBuildData({ result, changeSet, actions, timestamp, builtOn }) {
+    const params = actions.find(item => typeof item.parameters === 'object');
+    params.parameters.forEach(pair => {
+      this.params[pair.name] = pair.value;
+    });
+
+    this.change = changeSet.items[0] || {};
+    this.date = new Date(timestamp);
+    this.result = result;
+    this.builtOn = builtOn;
+  }
+
+  setDailyBuildData({ result, changeSet, timestamp, builtOn }) {
+    this.change = changeSet.items[0] || {};
+    this.date = new Date(timestamp);
+    this.result = result;
+    this.builtOn = builtOn;
+  }
+
+  get sourceURL() {
+    const { params } = this;
+
+    if (params.PR_ID) {  // from a node-test-pull-request build
+      const owner = params.TARGET_GITHUB_ORG;
+      const repo = params.TARGET_REPO_NAME;
+      const prid = params.PR_ID;
+      return `https://github.com/${owner}/${repo}/pull/${prid}/`;
+    }
+
+    if (params.GITHUB_ORG) {  // from a node-test-commit build
+      const owner = params.GITHUB_ORG;
+      const repo = params.REPO_NAME;
+      const prm = params.GIT_REMOTE_REF.match(/refs\/pull\/(\d+)\/head/);
+      if (prm) {
+        return `https://github.com/${owner}/${repo}/pull/${prm[1]}/`;
+      } else {
+        const result =
+          `https://api.github.com/repos/${owner}/${repo}/git/` +
+          params.GIT_REMOTE_REF;
+        return result;
+      }
+    }
+  }
+
+  get commit() {
+    const { change } = this;
+    if (!change.commitId) {
+      return 'Unknown';
+    }
+    return `[${shortSha(change.commitId)}] ${change.msg}`;
+  }
+
+  get author() {
+    const { change } = this;
+    if (!change.author) {
+      return 'Unknown';
+    }
+    return `${change.author.fullName} <${change.authorEmail}>`;
+  }
+
+  displayHeader() {
+    const { cli, result, change } = this;
+    cli.separator('Summary');
+    cli.table('Result', resultName(result));
+    cli.table('URL', this.jobUrl);
+    cli.table('Source', this.sourceURL);
+    cli.table('Commit', this.commit);
+    cli.table('Date', change.date);
+    cli.table('Author', this.author);
+  }
+
+  displayFailure(failure) {
+    const { cli } = this;
+    const { url, reason } = failure;
+    cli.separator(getNodeName(url));
+    cli.table('URL', url);
+    if (failure.type) {
+      cli.table('Type', failure.type);
+    }
+    if (failure.builtOn) {
+      cli.table('Built On', failure.builtOn);
+    }
+    if (!reason.includes('\n') && reason.length < 40) {
+      cli.table('Reason', chalk.red(reason));
+    } else {
+      cli.table('Reason', '');
+      const lines = reason.split('\n');
+      cli.log(`  ${chalk.red(lines[0])}`);
+      for (let i = 1; i < lines.length; ++i) {
+        cli.log(`  ${lines[i]}`);
+      }
+    }
+  }
+
+  displayBuilds() {
+    const { cli, failures, builds } = this;
+    for (const failure of failures) {
+      if (failure !== undefined) {
+        this.displayFailure(failure);
+      }
+    }
+    cli.separator('Other builds');
+    for (const aborted of builds.aborted) {
+      cli.table('Aborted', getUrl(aborted.url));
+    }
+    for (const pending of builds.pending) {
+      cli.table('Pending', getUrl(pending.url));
+    }
+    for (const unstable of builds.unstable) {
+      cli.table('Unstable', getUrl(unstable.url));
+    }
+  }
+
+  display() {
+    this.displayHeader();
+    this.displayBuilds();
+  }
+
+  formatAsMarkdown() {
+    if (this.result === statusType.SUCCESS) {
+      return `Job ${this.jobUrl} is green.`;
+    }
+    const { failures } = this;
+    let output = `Failures in job ${this.jobUrl}\n\n`;
+    for (const failure of failures) {
+      if (failure === undefined) continue;
+      output += `#### [${getNodeName(failure.url)}](${failure.url})`;
+      if (!failure.reason.includes('\n') && failure.reason.length < 20) {
+        const builtOn = failure.builtOn ? `On ${failure.builtOn}: ` : '';
+        output += `\n\n${builtOn}${failure.reason}\n`;
+      } else {
+        output += '\n\n';
+        const builtOn = failure.builtOn ? ` on ${failure.builtOn}:` : '';
+        output += fold(`See failures${builtOn}`, failure.reason) + '\n\n';
+      }
+    }
+    return output;
+  }
+
+  formatAsJson() {
+    const { jobUrl, failures, sourceURL } = this;
+
+    const result = failures.map(item => Object.assign({
+      source: sourceURL,
+      upstream: jobUrl
+    }, item));
+
+    return JSON.parse(JSON.stringify(result));
+  }
+}

package/lib/ci/build-types/test_run.js

@@ -0,0 +1,41 @@
+import { RUN_TREE } from '../jenkins_constants.js';
+import { getPath } from '../ci_utils.js';
+import CIFailureParser from '../ci_failure_parser.js';
+import { Job } from './job.js';
+
+const {
+  FAILURE_TYPES: { NCU_FAILURE },
+  FAILURE_CONSTRUCTORS: {
+    [NCU_FAILURE]: NCUFailure
+  }
+} = CIFailureParser;
+
+export class TestRun extends Job {
+  constructor(cli, request, url) {
+    const path = getPath(url);
+    const tree = RUN_TREE;
+    super(cli, request, path, tree);
+
+    this.failures = [];
+    this.cause = {};
+    this.builtOn = undefined;
+  }
+
+  async getData() {
+    let data;
+    try {
+      data = await this.getAPIData();
+    } catch (err) {
+      this.failures = [
+        new NCUFailure({ url: this.apiUrl }, err.message)
+      ];
+      return this.failures;
+    }
+    this.causes = this.getCause(data.actions) || {};
+    this.builtOn = data.builtOn;
+  }
+
+  async getResults() {
+    return this.parseConsoleText();
+  }
+}