@node-core/utils 4.0.0

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

@@ -0,0 +1,72 @@
+import { fold } from '../ci_utils.js';
+import { Job } from './job.js';
+
+export class BenchmarkRun extends Job {
+  constructor(cli, request, id) {
+    const path = `job/benchmark-node-micro-benchmarks/${id}/`;
+    super(cli, request, path);
+
+    this.results = '';
+    this.significantResults = '';
+  }
+
+  async getResults() {
+    const { path, cli } = this;
+    cli.startSpinner(`Querying results of ${path}`);
+    const text = await this.getConsoleText();
+    const index = text.indexOf('improvement');
+    if (index === -1) {
+      throw new Error('Not finished');
+    }
+    const breakIndex = text.lastIndexOf('\n', index);
+    const results = text.slice(breakIndex + 1)
+      .replace(/\nSending e-mails[\s\S]+/mg, '');
+    this.results = results;
+    cli.stopSpinner('Data downloaded');
+    this.significantResults = this.getSignificantResults(results);
+    return results;
+  }
+
+  getSignificantResults(data) {
+    const lines = data.split('\n');
+    const significant = lines.filter(line => line.indexOf('*') !== -1);
+    return significant.slice(0, -3).join('\n');
+  }
+
+  display() {
+    const { cli, results, significantResults } = this;
+    cli.log(results);
+    cli.separator('significant results');
+    cli.log(significantResults);
+  }
+
+  formatAsMarkdown() {
+    const { results, significantResults } = this;
+    const output = (fold('Benchmark results', results) + '\n\n' +
+                    fold('Significant impact', significantResults) + '\n');
+    return output;
+  }
+
+  formatAsJson() {
+    const results = this.significantResults.split('\n').slice(1);
+    const json = [];
+    for (const line of results) {
+      const star = line.indexOf('*');
+      const name = line.slice(0, star).trim();
+      const [file, ...config] = name.split(' ');
+      const confidence = line.match(/(\*+)/)[1];
+      const lastStar = line.lastIndexOf('*');
+      const [improvement, ...accuracy] =
+        line.slice(lastStar + 1).split(/\s*%/).map(i => i.trim() + '%');
+      accuracy.pop(); // remove the last empty item
+      json.push({
+        file,
+        config,
+        confidence,
+        improvement,
+        accuracy
+      });
+    }
+    return json;
+  }
+}

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

@@ -0,0 +1,194 @@
+import { flatten } from '../../utils.js';
+import { getNodeName, pad } from '../ci_utils.js';
+import {
+  CITGM_MAIN_TREE,
+  CITGM_REPORT_TREE
+} from '../jenkins_constants.js';
+import CIFailureParser from '../ci_failure_parser.js';
+import { TestBuild } from './test_build.js';
+
+const {
+  FAILURE_TYPES: { NCU_FAILURE },
+  FAILURE_CONSTRUCTORS: {
+    [NCU_FAILURE]: NCUFailure
+  }
+} = CIFailureParser;
+
+export class CITGMBuild extends TestBuild {
+  constructor(cli, request, job) {
+    const { jobid, noBuild } = job;
+    const path = noBuild
+      ? `job/citgm-smoker-nobuild/${jobid}/`
+      : `job/citgm-smoker/${jobid}/`;
+
+    const tree = CITGM_MAIN_TREE;
+
+    super(cli, request, path, tree);
+
+    this.id = jobid;
+    this.noBuild = noBuild;
+    this.failures = [];
+  }
+
+  async getResults() {
+    const { apiUrl, cli } = this;
+
+    let headerData;
+    try {
+      headerData = await this.getBuildData('Summary');
+    } catch (err) {
+      cli.stopSpinner('Failed to download Summary data',
+        cli.SPINNER_STATUS.FAILED);
+      this.failures.push(new NCUFailure({ url: this.apiUrl }, err.message));
+      return this.failures;
+    }
+    const { result } = headerData;
+
+    this.setBuildData(headerData);
+
+    // CITGM jobs store results in a different location than
+    // they do summary data, so we need to update the endpoint
+    // and issue a second API call in order to fetch result data.
+    this.tree = CITGM_REPORT_TREE;
+    this.updatePath(true);
+    let resultData;
+    try {
+      resultData = await this.getBuildData('Results');
+    } catch (err) {
+      cli.stopSpinner('Failed to download Results data',
+        cli.SPINNER_STATUS.FAILED);
+      this.failures.push(new NCUFailure({ url: apiUrl }, err.message));
+      return this.failures;
+    }
+
+    this.results = this.parseResults(resultData);
+
+    // Update id again so that it correctly displays in Summary output.
+    this.updatePath(false);
+
+    return { result };
+  }
+
+  parseResults(data) {
+    const { childReports, totalCount, skipCount, failCount } = data;
+    const results = { all: {}, failures: {}, statistics: {} };
+    const failureStatuses = ['FAILED', 'REGRESSION'];
+
+    const passCount = totalCount - failCount - skipCount;
+    results.statistics.passed = passCount;
+    results.statistics.total = totalCount;
+    results.statistics.skipped = skipCount;
+    results.statistics.failed = failCount;
+
+    childReports.forEach(platform => {
+      const cases = flatten(platform.result.suites[0].cases);
+      const url = platform.child.url;
+      const nodeName = getNodeName(url);
+
+      results.all[nodeName] = { url, modules: cases };
+
+      const failedModules = cases.filter(c => {
+        return failureStatuses.includes(c.status);
+      });
+
+      results.failures[nodeName] = { url, modules: failedModules };
+    });
+
+    return results;
+  }
+
+  updatePath(testReport) {
+    const { id, noBuild } = this;
+    if (testReport) {
+      this.path = noBuild
+        ? `job/citgm-smoker-nobuild/${id}/testReport/`
+        : `job/citgm-smoker/${id}/testReport/`;
+    } else {
+      this.path = noBuild
+        ? `job/citgm-smoker-nobuild/${id}/`
+        : `job/citgm-smoker/${id}/`;
+    }
+  }
+
+  display() {
+    const { failures } = this;
+
+    if (failures.length) {
+      for (const failure of failures) {
+        this.displayFailure(failure);
+      }
+      return;
+    }
+
+    this.displayHeader();
+    this.displayBuilds();
+  }
+
+  displayBuilds() {
+    const { cli, results } = this;
+    const { failed, skipped, passed, total } = results.statistics;
+
+    cli.separator('Statistics');
+    console.table({
+      Failed: failed,
+      Skipped: skipped,
+      Passed: passed,
+      Total: total
+    });
+
+    cli.separator('Failures');
+    const output = {};
+    for (const platform in results.failures) {
+      const modules = results.failures[platform].modules;
+      const failures = modules.map(f => f.name);
+
+      output[platform] = failures;
+    }
+
+    console.table(output);
+  }
+
+  formatAsJson() {
+    const { jobUrl, results, sourceURL } = this;
+
+    const result = {
+      source: sourceURL,
+      upstream: jobUrl,
+      ...results.statistics,
+      ...results.failures
+    };
+
+    return JSON.parse(JSON.stringify(result));
+  }
+
+  formatAsMarkdown() {
+    const { jobUrl, result, results, id } = this;
+
+    let output = `# CITGM Data for [${id}](${jobUrl})\n\n`;
+
+    const { failed, skipped, passed, total } = results.statistics;
+
+    output += `## Statistics for job [${id}](${jobUrl})\n\n`;
+    output += '|  FAILED  |  SKIPPED  |  PASSED  |  TOTAL  |\n';
+    output += '| -------- | --------- | -------- | ------- |\n';
+    output += `| ${pad(failed, 8)} | ${pad(skipped, 9)} |`;
+    output += ` ${pad(passed, 8)} | ${pad(total, 7)} |\n\n`;
+
+    if (result === 'success') {
+      output += `Job [${id}](${jobUrl}) is green.`;
+      return output;
+    }
+
+    output += `## Failures in job [${id}](${jobUrl})\n\n`;
+    for (const failure in results.failures) {
+      const data = results.failures[failure];
+      output += `### [${failure}](${data.url})\n\n`;
+
+      const failures = data.modules.map(f => `* ${f.name}`);
+      const items = failures.length > 0 ? `${failures.join('\n')}` : 'None.';
+      output += `${items}\n\n`;
+    }
+
+    return output;
+  }
+}

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

@@ -0,0 +1,174 @@
+import { statusType } from '../ci_utils.js';
+import { CITGMBuild } from './citgm_build.js';
+
+export class CITGMComparisonBuild {
+  constructor(cli, request, job) {
+    const { jobid, jobid2, noBuild } = job;
+
+    const baseBuild = new CITGMBuild(cli, request, { jobid, noBuild });
+
+    // noBuild in a comparison build only applies to the base build.
+    const comparisonBuild = new CITGMBuild(cli, request, {
+      jobid: jobid2,
+      noBuild: false
+    });
+
+    this.cli = cli;
+    this.builds = { baseBuild, comparisonBuild };
+    this.results = {};
+    this.failures = { baseBuild: [], comparisonBuild: [] };
+  }
+
+  async getResults() {
+    const { builds } = this;
+    const { baseBuild, comparisonBuild } = builds;
+
+    // Result in a comparison context reflects
+    // whether or not there were failures in
+    // comparisonBuild not present in baseBuild,
+    // e.g if there were new failures.
+    let result = statusType.SUCCESS;
+
+    await baseBuild.getResults();
+    await comparisonBuild.getResults();
+
+    if (baseBuild.failures.length || comparisonBuild.failures.length) {
+      this.failures.baseBuild =
+        this.failures.baseBuild.concat(baseBuild.failures);
+      this.failures.comparisonBuild =
+        this.failures.comparisonBuild.concat(comparisonBuild.failures);
+      return;
+    }
+
+    const { failures: baseFailures } = baseBuild.results;
+    const { failures: comparisonFailures } = comparisonBuild.results;
+
+    const failures = {};
+    for (const platform in comparisonFailures) {
+      // Account for no failure on this platform, or different platform.
+      if (!Object.prototype.hasOwnProperty.call(baseFailures, platform)) {
+        failures[platform] = [];
+        continue;
+      }
+
+      const baseModules = baseFailures[platform].modules.map(f => {
+        return f.name;
+      });
+      const comparisonModules = comparisonFailures[platform].modules.map(f => {
+        return f.name;
+      });
+
+      // Filter for every failed module in the comparison job module set
+      // that is not present in the failure set for the base job module set.
+      const newFailures = comparisonModules.filter(f => {
+        return !baseModules.includes(f);
+      });
+      if (newFailures.length !== 0) {
+        result = statusType.FAILURE;
+      }
+
+      failures[platform] = newFailures;
+    }
+
+    this.results.failures = failures;
+    this.result = result;
+
+    return result;
+  }
+
+  display() {
+    const { builds, failures } = this;
+
+    if (failures.baseBuild.length || failures.comparisonBuild.length) {
+      for (const failure of failures.baseBuild) {
+        builds.baseBuild.displayFailure(failure);
+      }
+      for (const failure of failures.comparisonBuild) {
+        builds.comparisonBuild.displayFailure(failure);
+      }
+      return;
+    }
+
+    // Display header for both CITGM runs.
+    builds.baseBuild.displayHeader();
+    builds.comparisonBuild.displayHeader();
+
+    this.displayBuilds();
+  }
+
+  displayBuilds() {
+    const { builds, cli, results, result } = this;
+
+    const bID = builds.baseBuild.id;
+    const cID = builds.comparisonBuild.id;
+
+    cli.separator('Results');
+
+    if (result === statusType.SUCCESS) {
+      cli.log('\n\n');
+      const str = `No new failures in ${cID} compared to ${bID}`;
+      cli.log(`${statusType.SUCCESS}: ${str}\n\n`);
+      return;
+    }
+
+    const output = {};
+    let totalFailures = 0;
+    for (const platform in results.failures) {
+      const failures = results.failures[platform];
+      totalFailures += failures.length;
+
+      output[platform] = failures;
+    }
+
+    cli.log('\n\n');
+    const str = `${totalFailures} failures in ${cID} not present in ${bID}`;
+    cli.log(`${statusType.FAILURE}: ${str}\n\n`);
+    console.table(output);
+  }
+
+  formatAsJson() {
+    const { builds, results } = this;
+    const { baseBuild, comparisonBuild } = builds;
+
+    const result = {
+      baseBuild: {
+        source: baseBuild.sourceURL,
+        upstream: comparisonBuild.jobUrl
+      },
+      comparisonBuild: {
+        source: comparisonBuild.sourceURL,
+        upstream: baseBuild.jobUrl
+      },
+      ...results.failures
+    };
+
+    return JSON.parse(JSON.stringify(result));
+  }
+
+  formatAsMarkdown() {
+    const { builds, result, results } = this;
+    const { baseBuild, comparisonBuild } = builds;
+
+    const bLink = `[#${baseBuild.id}](${baseBuild.jobUrl})`;
+    const cLink = `[#${comparisonBuild.id}](${comparisonBuild.jobUrl})`;
+
+    let output = `# CITGM Data for ${bLink} - ${cLink}\n\n`;
+
+    if (result === 'success') {
+      const bID = baseBuild.id;
+      const cID = comparisonBuild.id;
+      output += `No new failures in ${cID} compared to ${bID}`;
+      return output;
+    }
+
+    output += `## New Failures in job ${cLink}\n\n`;
+    for (const failure in results.failures) {
+      const data = results.failures[failure];
+      output += `### ${failure}\n\n`;
+
+      const failures = data.map(f => `* ${f}`);
+      output += failures.length ? `${failures.join('\n')}\n\n` : 'None.\n\n';
+    }
+    return output;
+  }
+}

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

@@ -0,0 +1,112 @@
+import { flatten } from '../../utils.js';
+import { statusType } from '../ci_utils.js';
+import { COMMIT_TREE } from '../jenkins_constants.js';
+import CIFailureParser from '../ci_failure_parser.js';
+import { TestBuild } from './test_build.js';
+import { FannedBuild } from './fanned_build.js';
+import { LinterBuild } from './linter_build.js';
+import { NormalBuild } from './normal_build.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 CommitBuild extends TestBuild {
+  constructor(cli, request, id) {
+    const path = `job/node-test-commit/${id}/`;
+    const tree = COMMIT_TREE;
+    super(cli, request, path, tree);
+  }
+
+  getBuilds({ result, subBuilds }) {
+    if (result === statusType.SUCCESS) {
+      const builds = this.builds = {
+        failed: [], aborted: [], pending: [], unstable: []
+      };
+      return { result: statusType.SUCCESS, builds };
+    }
+
+    const failed = subBuilds.filter(build => {
+      return build.result === statusType.FAILURE;
+    });
+    const aborted = subBuilds.filter(build => {
+      return build.result === statusType.ABORTED;
+    });
+    const pending = subBuilds.filter(build => {
+      return build.result === null;
+    });
+    const unstable = subBuilds.filter(build => {
+      return build.result === statusType.UNSTABLE;
+    });
+
+    // build: { buildNumber, jobName, result, url }
+    const builds = this.builds = { failed, aborted, pending, unstable };
+    return { result, builds };
+  }
+
+  // Get the failures and their reasons of this build
+  async getResults(data) {
+    const { path, cli, request } = this;
+
+    if (!data) {
+      try {
+        data = await this.getBuildData();
+      } catch (err) {
+        this.failures = [
+          new NCUFailure({ url: this.apiUrl }, err.message)
+        ];
+        return this.failures;
+      }
+    }
+    this.setBuildData(data);
+    // No builds at all
+    if (data.result === statusType.FAILURE && !data.subBuilds.length) {
+      const failure = new BuildFailure(this, 'Failed to trigger sub builds');
+      this.failures = [failure];
+      return {
+        result: data.result,
+        builds: { failed: [], aborted: [], pending: [], unstable: [] },
+        failures: this.failures
+      };
+    }
+
+    const { result, builds } = this.getBuilds(data);
+
+    if (result !== statusType.FAILURE) {
+      return { result, builds, failures: [] };
+    }
+
+    if (!builds.failed.length) {
+      const failures = await this.parseConsoleText();
+      return { result, builds, failures };
+    }
+
+    cli.startSpinner(`Querying failures of ${path}`);
+    const promises = builds.failed.map(({ jobName, buildNumber, url }) => {
+      if (jobName.includes('fanned')) {
+        const cause = this.getCause(data.actions);
+        const isResumed = cause && cause._class.includes('ResumeCause');
+        return new FannedBuild(cli, request, jobName, buildNumber, isResumed)
+          .getResults();
+      } else if (jobName.includes('linter')) {
+        return new LinterBuild(cli, request, jobName, buildNumber).getResults();
+      } else if (jobName.includes('freestyle')) {
+        return new TestRun(cli, request, url).getResults();
+      }
+      return new NormalBuild(cli, request, jobName, buildNumber).getResults();
+    });
+    const rawFailures = await Promise.all(promises);
+
+    const failures = this.failures = flatten(rawFailures);
+    cli.stopSpinner('Data downloaded');
+    return { result, failures, builds };
+  }
+}

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

@@ -0,0 +1,24 @@
+import { PR_TREE } from '../jenkins_constants.js';
+import { TestBuild } from './test_build.js';
+
+export class DailyBuild extends TestBuild {
+  constructor(cli, request, id) {
+    const path = `job/node-daily-master/${id}/`;
+    const tree = PR_TREE;
+    super(cli, request, path, tree);
+
+    this.commitBuild = null;
+  }
+
+  formatAsMarkdown() {
+    if (!this.commitBuild) {
+      let result = 'Failed to trigger node-daily-master';
+      if (this.builtOn) {
+        result += ` on ${this.builtOn}`;
+      }
+      result += `\n\nURL: ${this.jobUrl}`;
+      return result;
+    }
+    return super.formatAsMarkdown();
+  }
+}

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

@@ -0,0 +1,87 @@
+import { statusType } from '../ci_utils.js';
+import { flatten } from '../../utils.js';
+import { FANNED_TREE } from '../jenkins_constants.js';
+import CIFailureParser from '../ci_failure_parser.js';
+import { Job } from './job.js';
+import { NormalBuild } from './normal_build.js';
+
+const {
+  FAILURE_TYPES: {
+    BUILD_FAILURE,
+    NCU_FAILURE,
+    GIT_FAILURE,
+    RESUME_FAILURE
+  },
+  FAILURE_CONSTRUCTORS: {
+    [BUILD_FAILURE]: BuildFailure,
+    [NCU_FAILURE]: NCUFailure,
+    [RESUME_FAILURE]: ResumeFailure
+  }
+} = CIFailureParser;
+
+export class FannedBuild extends Job {
+  constructor(cli, request, jobName, id, isResumed) {
+    // assert(jobName.includes('fanned'));
+    const path = `job/${jobName}/${id}/`;
+    const tree = FANNED_TREE;
+    super(cli, request, path, tree);
+
+    this.failures = [];
+    this.builtOn = undefined;
+    this.isResumed = isResumed;
+  }
+
+  // Get the failures and their reasons of this build
+  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;
+    }
+    this.builtOn = data.builtOn;
+
+    if (!data.subBuilds.length) {
+      this.failures = [
+        new BuildFailure(this, 'Failed to trigger fanned build')
+      ];
+      return this.failures;
+    }
+
+    const failedPhase = data.subBuilds.find(build => {
+      return build.result === statusType.FAILURE;
+    });
+
+    if (!failedPhase) {
+      return this.parseConsoleText();
+    }
+
+    const { jobName, buildNumber } = failedPhase;
+    const build = new NormalBuild(cli, request, jobName, buildNumber);
+    let failures = await build.getResults();
+    if (failures !== undefined) {
+      failures = flatten(failures);
+    }
+
+    if (this.isResumed) {
+      // XXX: if it's a resumed build, we replace the build/git failures
+      // with resume failures. Probably just a random guess, though
+      for (let i = 0; i < failures.length; ++i) {
+        const item = failures[i];
+        if (item.type === BUILD_FAILURE || item.type === GIT_FAILURE) {
+          failures[i] = new ResumeFailure(
+            item,
+            `Possible resume failure\n${item.reason}`
+          );
+        }
+      }
+    }
+    this.failures = failures;
+    return this.failures;
+  }
+}