@node-core/utils 4.0.0

package/lib/ci/ci_failure_parser.js

@@ -0,0 +1,325 @@
+function unique(arr) {
+  return Array.from(new Set(arr).values());
+}
+
+function pickContext(matches, text, {
+  index = 0,  // which one in the matches should be picked
+  contextBefore = 0,
+  contextAfter = 0
+}) {
+  if (index < 0) { index = matches.length + index; }
+  const match = matches[index];
+
+  const offset = text.indexOf(match);
+  let after = offset + match.length;
+  for (let i = 0; i < contextAfter; ++i) {
+    const next = text.indexOf('\n', after + 1);
+    after = next > 0 ? next : after;
+  }
+  let before = offset;
+  for (let i = 0; i < contextBefore; ++i) {
+    const next = text.lastIndexOf('\n', before - 1);
+    before = next > 0 ? next : before;
+  }
+
+  return text.slice(before, after);
+}
+
+const BUILD_FAILURE = 'BUILD_FAILURE';
+const JS_TEST_FAILURE = 'JS_TEST_FAILURE';
+const CC_TEST_FAILURE = 'CC_TEST_FAILURE';
+const JENKINS_FAILURE = 'JENKINS_FAILURE';
+const GIT_FAILURE = 'GIT_FAILURE';
+const NCU_FAILURE = 'NCU_FAILURE';
+const RESUME_FAILURE = 'RESUME_FAILURE';
+const INFRA_FAILURE = 'INFRA_FAILURE';
+
+const FAILURE_TYPES = {
+  BUILD_FAILURE, JS_TEST_FAILURE, CC_TEST_FAILURE,
+  JENKINS_FAILURE, GIT_FAILURE, NCU_FAILURE, RESUME_FAILURE,
+  INFRA_FAILURE
+};
+
+class CIResult {
+  constructor(ctx, reason) {
+    this.url = ctx.url || ctx.consoleUIUrl || ctx.jobUrl;
+    this.builtOn = ctx.builtOn;
+    this.reason = reason;
+    // Default: the first line is the highlight, we will slice
+    // the context to make it so.
+    // TODO: better highlights
+    this.highlight = 0;
+  }
+}
+
+// Usually need a fix to the build files
+class BuildFailure extends CIResult {
+  constructor(ctx, reason) {
+    super(ctx, reason);
+    this.type = BUILD_FAILURE;
+  }
+}
+
+// Usually needs to fix something in the Jenkins agent (or just restart it)
+class InfraFailure extends CIResult {
+  constructor(ctx, reason) {
+    super(ctx, reason);
+    this.type = INFRA_FAILURE;
+  }
+}
+
+// Usually needs a fix in the test or the core
+class JSTestFailure extends CIResult {
+  constructor(ctx, reason) {
+    super(ctx, reason);
+    this.type = JS_TEST_FAILURE;
+    // Example: not ok 749 parallel/test-http-readable-data-event
+    this.file = this.reason.split('\n')[this.highlight].split(' ').pop();
+    this.severity = this.reason.match(/^\s+severity: (\w+)/m)[1];
+  }
+}
+
+// Usually needs a fix in the test or the core
+class CCTestFailure extends CIResult {
+  constructor(ctx, reason) {
+    super(ctx, reason);
+    this.type = CC_TEST_FAILURE;
+  }
+}
+
+// Usually needs someone to log into the machines and fix it
+class JenkinsFailure extends CIResult {
+  constructor(ctx, reason) {
+    super(ctx, reason);
+    this.type = JENKINS_FAILURE;
+  }
+}
+
+// Usually need a fix to the build scripts or in workers
+class GitFailure extends CIResult {
+  constructor(ctx, reason) {
+    super(ctx, reason);
+    this.type = GIT_FAILURE;
+  }
+}
+
+// Failures in this tool, we wrap them to avoid exceptions when
+// walking the CI
+class NCUFailure extends CIResult {
+  constructor(ctx, reason) {
+    super(ctx, reason);
+    this.type = NCU_FAILURE;
+  }
+}
+
+// Refs: https://github.com/nodejs/build/issues/1496
+class ResumeFailure extends CIResult {
+  constructor(ctx, reason) {
+    super(ctx, reason);
+    this.type = RESUME_FAILURE;
+  }
+}
+
+function failureMatcher(Failure, patterns, ctx, text) {
+  for (const pattern of patterns) {
+    const matches = text.match(pattern.pattern);
+    if (!matches) {
+      continue;
+    }
+    const reason = pickContext(matches, text, pattern.context).trim();
+    return [new Failure(ctx, reason)];
+  }
+  return null;
+}
+
+// The elements are ranked by priority
+const FAILURE_FILTERS = [{
+  // NOTE(mmarchini): infra-related issues should have the highest priority, as
+  // they can cause other issues to happen.
+  filter(ctx, text) {
+    const patterns = [{
+      pattern: /Read-only file system/g,
+      context: { index: 0, contextBefore: 1, contextAfter: 0 }
+    },
+    {
+      pattern: /Device or resource busy/g,
+      context: { index: 0, contextBefore: 1, contextAfter: 0 }
+    },
+    {
+      pattern: /There is not enough space in the file system./g,
+      context: { index: 0, contextBefore: 1, contextAfter: 0 }
+    }
+    ];
+    return failureMatcher(InfraFailure, patterns, ctx, text);
+  }
+}, {
+  // TODO: match indentation to avoid skipping context with '...'
+  filter(ctx, text) {
+    const pattern = /^not ok \d+[\s\S]+? {2}\.\.\.\r?\n/mg;
+    const matches = text.match(pattern);
+    if (!matches) {
+      return null;
+    }
+    const nonFlaky = matches.filter((m) => !m.includes('# TODO :'));
+    if (!nonFlaky.length) {
+      return null;
+    }
+    return unique(nonFlaky).map(
+      match => new JSTestFailure(ctx, match)
+    );
+  }
+}, {
+  filter(ctx, text) {
+    const patterns = [{
+      pattern: /\[ {2}FAILED {2}\].+/g,
+      context: { index: 0, contextBefore: 5, contextAfter: 0 }
+    }];
+    return failureMatcher(CCTestFailure, patterns, ctx, text);
+  }
+}, {
+  // VS compilation error
+  filter(ctx, text) {
+    const patterns = [{
+      pattern: /error C\d+:/mg,
+      context: { index: 0, contextBefore: 0, contextAfter: 5 }
+    }];
+    return failureMatcher(BuildFailure, patterns, ctx, text);
+  }
+}, {
+  filter(ctx, text) {
+    const patterns = [{
+      pattern: /java\.io\.IOException.+/g,
+      context: { index: -1, contextBefore: 0, contextAfter: 5 }
+    }, {
+      pattern: /Build timed out/g,
+      context: { index: 0, contextBefore: 0, contextAfter: 1 }
+    }];
+    return failureMatcher(JenkinsFailure, patterns, ctx, text);
+  }
+}, {
+  filter(ctx, text) {
+    const patterns = [{
+      pattern:
+        /Changes not staged for commit:[\s\S]+no changes added to commit/mg,
+      context: { index: 0, contextBefore: 0, contextAfter: 0 }
+    }, {
+      pattern:
+        // eslint-disable-next-line max-len
+        /error: Your local changes to the following files[\s\S]+Failed to merge in the changes./g,
+      context: { index: 0, contextBefore: 0, contextAfter: 0 }
+    }, {
+      pattern: /warning: failed to remove .+/g,
+      context: { index: 0, contextBefore: 0, contextAfter: 0 }
+    }];
+    return failureMatcher(GitFailure, patterns, ctx, text);
+  }
+}, {
+  filter(ctx, text) {
+    const patterns = [{
+      pattern: /ERROR: Error fetching .+/g,
+      context: { index: 0, contextBefore: 0, contextAfter: 5 }
+    }, {
+      pattern: /hudson\.plugins\.git\.GitException+/g,
+      context: { index: 0, contextBefore: 0, contextAfter: 5 }
+    }, {
+      pattern: /Cannot rebase: .+/g,
+      context: { index: 0, contextBefore: 0, contextAfter: 1 }
+    }];
+    return failureMatcher(GitFailure, patterns, ctx, text);
+  }
+}, {
+  filter(ctx, text) {
+    const patterns = [{
+      pattern: /sh: line /g,
+      context: { index: 0, contextBefore: 0, contextAfter: 1 }
+    }, {
+      pattern: /fatal error:/g,
+      context: { index: 0, contextBefore: 0, contextAfter: 1 }
+    }, {
+      pattern: /dtrace: failed to compile script/g,
+      context: { index: 0, contextBefore: 0, contextAfter: 1 }
+    }, {
+      pattern: /ERROR: .+/g,
+      // Pick the last one
+      context: { index: -1, contextBefore: 0, contextAfter: 5 }
+    }, {
+      // Pick the first one
+      pattern: /Error: .+/g,
+      context: { index: 0, contextBefore: 0, contextAfter: 5 }
+    }];
+    return failureMatcher(BuildFailure, patterns, ctx, text);
+  }
+}, {
+  filter(ctx, text) {
+    const pattern = /fatal: .+/g;
+    const matches = text.match(pattern);
+    if (!matches) {
+      return null;
+    }
+    const reason = unique(matches).join('\n');
+    return [new BuildFailure(ctx, reason)];
+  }
+}, {
+  filter(ctx, text) {
+    const patterns = [{
+      pattern: /FATAL: .+/g,
+      context: { index: -1, contextBefore: 0, contextAfter: 5 }
+    }, {
+      pattern: /make.*: write error/mg,
+      context: { index: 0, contextBefore: 0, contextAfter: 3 }
+    }, {
+      pattern: /error: .+/g,
+      context: { index: 0, contextBefore: 0, contextAfter: 5 }
+    }, {
+      pattern: /Makefile:.+failed/g,
+      context: { index: 0, contextBefore: 0, contextAfter: 5 }
+    }, {
+      pattern: /make.*: .+ Error \d.*/g,
+      context: { index: 0, contextBefore: 0, contextAfter: 3 }
+    }, {
+      pattern: /warning: failed .+/g,
+      context: { index: 0, contextBefore: 0, contextAfter: 3 }
+    }];
+    return failureMatcher(BuildFailure, patterns, ctx, text);
+  }
+}];
+
+export default class CIFailureParser {
+  constructor(ctx, text) {
+    this.ctx = ctx;
+    this.text = text;
+  }
+
+  parse() {
+    const text = this.text;
+    for (const { filter } of FAILURE_FILTERS) {
+      const result = filter(this.ctx, text);
+      // TODO: we may want to concat certain types of failures
+      if (result) {
+        return result;
+      }
+    }
+    return null;
+  }
+}
+
+CIFailureParser.FAILURE_TYPES = FAILURE_TYPES;
+CIFailureParser.FAILURE_CONSTRUCTORS = {
+  BUILD_FAILURE: BuildFailure,
+  JENKINS_FAILURE: JenkinsFailure,
+  JS_TEST_FAILURE: JSTestFailure,
+  CC_TEST_FAILURE: CCTestFailure,
+  GIT_FAILURE: GitFailure,
+  NCU_FAILURE: NCUFailure,
+  RESUME_FAILURE: ResumeFailure
+};
+CIFailureParser.CIResult = CIResult;
+CIFailureParser.FAILURE_TYPES_NAME = {
+  BUILD_FAILURE: 'Build Failure',
+  JENKINS_FAILURE: 'Jenkins Failure',
+  JS_TEST_FAILURE: 'JSTest Failure',
+  CC_TEST_FAILURE: 'CCTest Failure',
+  GIT_FAILURE: 'Git Failure',
+  NCU_FAILURE: 'node-core-utils failure',
+  RESUME_FAILURE: 'resume failure'
+};

package/lib/ci/ci_type_parser.js

@@ -0,0 +1,203 @@
+import { parsePRFromURL } from '../links.js';
+import PRData from '../pr_data.js';
+import { ascending } from '../utils.js';
+
+const CI_URL_RE = /\/\/ci\.nodejs\.org(\S+)/mg;
+export const CI_DOMAIN = 'ci.nodejs.org';
+
+// constants
+const CITGM = 'CITGM';
+const CITGM_NOBUILD = 'CITGM_NOBUILD';
+const PR = 'PR';
+const COMMIT = 'COMMIT';
+const BENCHMARK = 'BENCHMARK';
+const LIBUV = 'LIBUV';
+const NOINTL = 'NOINTL';
+const V8 = 'V8';
+const LINTER = 'LINTER';
+const DAILY_MASTER = 'DAILY_MASTER';
+
+const CI_TYPE_ENUM = {
+  FULL_CI: 1 << 0,
+  JOB_CI: 1 << 2
+};
+
+export const CI_PROVIDERS = {
+  GITHUB: 'github-check',
+  NODEJS: 'nodejs'
+};
+
+const { JOB_CI, FULL_CI } = CI_TYPE_ENUM;
+
+export const CI_TYPES = new Map([
+  [CITGM, {
+    name: 'CITGM',
+    jobName: 'citgm-smoker',
+    pattern: /job\/citgm-smoker\/(\d+)/,
+    type: JOB_CI
+  }],
+  [CITGM_NOBUILD, {
+    name: 'CITGM',
+    jobName: 'citgm-smoker-nobuild',
+    pattern: /job\/citgm-smoker-nobuild\/(\d+)/,
+    type: JOB_CI
+  }],
+  [PR, {
+    name: 'Full PR',
+    jobName: 'node-test-pull-request',
+    pattern: /job\/node-test-pull-request\/(\d+)/,
+    type: JOB_CI | FULL_CI
+  }],
+  [COMMIT, {
+    name: 'Full Commit',
+    jobName: 'node-test-commit',
+    pattern: /job\/node-test-commit\/(\d+)/,
+    type: JOB_CI | FULL_CI
+  }],
+  [BENCHMARK, {
+    name: 'Benchmark',
+    jobName: 'benchmark-node-micro-benchmarks',
+    pattern: /job\/benchmark-node-micro-benchmarks\/(\d+)/,
+    type: JOB_CI
+  }],
+  [LIBUV, {
+    name: 'libuv',
+    jobName: 'libuv-test-commit',
+    pattern: /job\/libuv-test-commit\/(\d+)/,
+    type: JOB_CI
+  }],
+  [NOINTL, {
+    name: 'No Intl',
+    jobName: 'node-test-commit-nointl',
+    pattern: /job\/node-test-commit-nointl\/(\d+)/,
+    type: JOB_CI
+  }],
+  [V8, {
+    name: 'V8',
+    jobName: 'node-test-commit-v8-linux',
+    pattern: /job\/node-test-commit-v8-linux\/(\d+)/,
+    type: JOB_CI
+  }],
+  [LINTER, {
+    name: 'Linter',
+    jobName: 'node-test-linter',
+    pattern: /job\/node-test-linter\/(\d+)/,
+    type: JOB_CI
+  }],
+  [DAILY_MASTER, {
+    name: 'Node Daily Master',
+    jobName: 'node-daily-master',
+    pattern: /job\/node-daily-master\/(\d+)/,
+    type: JOB_CI
+  }]
+]);
+
+export function isFullCI(key) {
+  const data = CI_TYPES.get(key);
+  if (!data) {
+    return false;
+  }
+  return !!(data.type & FULL_CI);
+}
+
+// Given a ci.nodejs.org/*** link, parse the job type and ID
+export function parseJobFromURL(url) {
+  if (typeof url !== 'string') {
+    return undefined;
+  }
+
+  for (const [type, info] of CI_TYPES) {
+    const match = url.match(info.pattern);
+    if (match) {
+      return {
+        link: url,
+        jobid: parseInt(match[1]),
+        type
+      };
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Parse links of CI Jobs posted in a GitHub thread
+ */
+export class JobParser {
+  /**
+   * @param {{bodyText: string, publishedAt: string}[]} thread
+   */
+  constructor(thread) {
+    this.thread = thread.sort(
+      (a, b) => ascending(a.publishedAt, b.publishedAt)
+    );
+  }
+
+  /**
+   * @returns {Map<string, {link: string, date: string, jobid: number}>}
+   */
+  parse() {
+    const thread = this.thread;
+    const result = new Map();
+    for (const c of thread) {
+      const text = c.bodyText;
+      if (!text.includes(CI_DOMAIN)) continue;
+      const jobs = this.parseText(text);
+      for (const job of jobs) {
+        // Always take the last one
+        // TODO(joyeecheung): exlcude links wrapped in `<del>`
+        result.set(job.type, {
+          link: job.link,
+          date: c.publishedAt,
+          jobid: job.jobid
+        });
+      }
+    }
+    return result;
+  }
+
+  /**
+   * @param {string} text
+   * @returns {{link: string, jobid: number, type: string}}
+   */
+  parseText(text) {
+    const links = text.match(CI_URL_RE);
+    if (!links) {
+      return [];
+    }
+
+    const result = [];
+    for (const link of links) {
+      const parsed = parseJobFromURL(`https:${link}`);
+      if (parsed) {
+        result.push(parsed);
+      }
+    }
+
+    return result;
+  }
+}
+
+JobParser.fromPR = async function(url, cli, request) {
+  const argv = parsePRFromURL(url);
+  if (!argv) {
+    return undefined;
+  }
+  const data = new PRData(argv, cli, request);
+  await data.getThreadData();
+  const thread = data.getThread();
+  return new JobParser(thread);
+};
+
+export const CI_TYPES_KEYS = {
+  CITGM,
+  CITGM_NOBUILD,
+  PR,
+  COMMIT,
+  BENCHMARK,
+  LIBUV,
+  V8,
+  NOINTL,
+  LINTER,
+  DAILY_MASTER
+};

package/lib/ci/ci_utils.js

@@ -0,0 +1,106 @@
+import qs from 'node:querystring';
+
+import {
+  CI_DOMAIN,
+  parseJobFromURL,
+  CI_TYPES
+} from './ci_type_parser.js';
+
+export const statusType = {
+  SUCCESS: 'SUCCESS',
+  FAILURE: 'FAILURE',
+  ABORTED: 'ABORTED',
+  UNSTABLE: 'UNSTABLE'
+};
+
+export function getPath(url) {
+  return url.replace(`https://${CI_DOMAIN}/`, '').replace('api/json', '');
+}
+
+export function getNodeName(url) {
+  const re = /\/nodes=(.+?)\//;
+  if (re.test(url)) {
+    return url.match(re)[1];
+  }
+  const parts = url.split('/');
+  return parts[parts.length - 3];
+}
+
+export function fold(summary, code) {
+  const dataBlock = '```\n' + code + '\n```';
+  const summaryBlock = `\n<summary>${summary}</summary>\n`;
+  return `<details>${summaryBlock}\n${dataBlock}\n</details>`;
+}
+
+export function pad(any, length) {
+  return (any + '').padEnd(length);
+}
+
+export function markdownRow(...args) {
+  let result = '';
+  for (const item of args) {
+    result += `| ${item} `;
+  }
+  return result + '|\n';
+}
+
+function filterBuild(builds, type) {
+  return builds
+    .filter(build => build.result === type)
+    .map(build => parseJobFromURL(build.url));
+}
+
+export async function listBuilds(cli, request, type, since) {
+  // assert(type === COMMIT || type === PR)
+  const { jobName } = CI_TYPES.get(type);
+  const tree = 'builds[url,result,timestamp]';
+  const url = `https://${CI_DOMAIN}/job/${jobName}/api/json?tree=${qs.escape(tree)}`;
+
+  cli.startSpinner(`Querying ${url}`);
+
+  const result = await request.json(url);
+  let builds = result.builds;
+  if (since) {
+    builds = builds.filter(build => build.timestamp > since);
+  }
+  const failed = filterBuild(builds, statusType.FAILURE);
+  const aborted = filterBuild(builds, statusType.ABORTED);
+  const pending = filterBuild(builds, null);
+  const unstable = filterBuild(builds, statusType.UNSTABLE);
+  const success = filterBuild(builds, statusType.SUCCESS);
+  cli.stopSpinner('Done');
+
+  return {
+    success,
+    failed,
+    aborted,
+    pending,
+    unstable,
+    count: builds.length
+  };
+}
+
+export function getHighlight(f) {
+  if (!f.reason) {
+    f.reason = 'failure not found';
+    return f.reason;
+  }
+  return f.reason.split('\n')[f.highlight]
+    .replace(/not ok \d+ /, '')
+    .replace(
+      /JNLP4-connect connection from \S+/, 'JNLP4-connect connection from ...'
+    )
+    .replace(/FATAL: Could not checkout \w+/, 'FATAL: Could not checkout ...')
+    .replace(
+      /error: pathspec .+ did not match any file\(s\) known to git/,
+      'error: pathspec ... did not match any file(s) known to git')
+    .replace(
+      /failed: no workspace for .+/,
+      'failed: no workspace for ...'
+    )
+    .replace(
+      /fatal: loose object \w+ \(stored in .git\/objects\/.+\) is corrupt/,
+      'fatal: loose object ... (stored in .git/objects/...) is corrupt')
+    .replace(/hudson\.plugins\.git\.GitException: /, '')
+    .replace(/java\.io\.IOException: /, '');
+}