main.ts

import ge = require("./getErrors");
import pu = require("./packageUtils");
import git = require("./gitUtils");
import ip = require("./installPackages");
import ur = require("./userRepos");
import cp = require("child_process");
import fs = require("fs");
import path = require("path");

export interface Params {
    /** True to post the result to Github, false to print to console.  */
    postResult: boolean;
    /** Store test repos on a tmpfs */
    tmpfs: boolean;
    /**
     * Number of repos to test, undefined for the default.
     * Git repos are chosen randomly; default is 100.
     * User repos start at the top of the list; default is all of them.
     */
    repoCount?: number | undefined;
    oldTypescriptRepoUrl: string;
    oldHeadRef: string;
    sourceIssue: number;
    requestingUser: string;
    statusComment: number;
}

const skipRepos = [
    "https://github.com/storybookjs/storybook", // Too big to fit on VM
    "https://github.com/microsoft/frontend-bootcamp", // Can't be built twice in a row
];
const processCwd = process.cwd();
const processPid = process.pid;
const executionTimeout = 10 * 60 * 1000;
export async function innerloop(params: Params, downloadDir: string, userTestDir: string, repo: git.Repo, oldTscPath: string, newTscPath: string, outputs: string[]) {
    if (params.tmpfs)
        await execAsync(processCwd, "sudo mount -t tmpfs -o size=2g tmpfs " + downloadDir);

    try {
        if (repo.url) {
            try {
                console.log("Cloning if absent");
                await git.cloneRepoIfNecessary(downloadDir, repo);
            }
            catch (err) {
                reportError(err, "Error cloning " + repo.url);
                return;
            }
        }
        else {
            await ur.copyUserRepo(downloadDir, userTestDir, repo);
        }

        const repoDir = path.join(downloadDir, repo.name);

        try {
            console.log("Installing packages if absent");
            await withTimeout(executionTimeout, installPackages(repoDir, repo.types));
        }
        catch (err) {
            reportError(err, "Error installing packages for " + repo.name);
            await reportResourceUsage(downloadDir);
            return;
        }

        try {
            console.log(`Building with ${oldTscPath} (old)`);
            const oldErrors = await buildAndGetErrors(repoDir, oldTscPath, /*skipLibCheck*/ true, params.postResult);

            if (oldErrors.hasConfigFailure) {
                console.log("Unable to build project graph");
                console.log(`Skipping build with ${newTscPath} (new)`);
                return;
            }

            const numProjects = oldErrors.projectErrors.length;

            let numFailed = 0;
            for (const oldProjectErrors of oldErrors.projectErrors) {
                if (oldProjectErrors.hasBuildFailure || oldProjectErrors.errors.length) {
                    numFailed++;
                }
            }

            // User tests ignores build failures.
            let sawNewRepoErrors = false;
            const owner = repo.owner ? `${repo.owner}/` : "";
            const url = repo.url ? `(${repo.url})` : "";

            let repoSummary = `# [${owner}${repo.name}]${url}\n`;

            if (numFailed > 0) {
                const oldFailuresMessage = `${numFailed} of ${numProjects} projects failed to build with the old tsc`;
                console.log(oldFailuresMessage);
                repoSummary += `**${oldFailuresMessage}**\n`;
            }

            console.log(`Building with ${newTscPath} (new)`);
            const newErrors = await buildAndGetErrors(repoDir, newTscPath, /*skipLibCheck*/ true, params.postResult);

            if (newErrors.hasConfigFailure) {
                console.log("Unable to build project graph");

                repoSummary += ":exclamation::exclamation: **Unable to build the project graph with the new tsc** :exclamation::exclamation:\n";

                outputs.push(repoSummary)
                return true;
            }

            console.log("Comparing errors");
            for (const oldProjectErrors of oldErrors.projectErrors) {
                // TS 5055 generally indicates that the project can't be built twice in a row without cleaning in between.
                // Filter out errors reported already on "old".
                const newProjectErrors = newErrors.projectErrors.find(pe => pe.projectUrl == oldProjectErrors.projectUrl)?.errors?.filter(e => e.code !== 5055)
                    .filter(ne => !oldProjectErrors.errors.find(oe => ge.errorEquals(oe, ne)));
                if (!newProjectErrors?.length) {
                    continue;
                }

                sawNewRepoErrors = true;

                const errorMessageMap = new Map<string, ge.Error[]>();
                const errorMessages: string[] = [];

                console.log(`New errors for ${oldProjectErrors.isComposite ? "composite" : "non-composite"} project ${oldProjectErrors.projectUrl}`);
                for (const newError of newProjectErrors) {
                    const newErrorText = newError.text;

                    console.log(`\tTS${newError.code} at ${newError.fileUrl ?? "project scope"}${oldProjectErrors.isComposite ? ` in ${newError.projectUrl}` : ``}`);
                    console.log(`\t\t${newErrorText}`);

                    if (!errorMessageMap.has(newErrorText)) {
                        errorMessageMap.set(newErrorText, []);
                        errorMessages.push(newErrorText);
                    }

                    errorMessageMap.get(newErrorText)!.push(newError);
                }

                repoSummary += `### ${makeMarkdownLink(oldProjectErrors.projectUrl)}\n`
                for (const errorMessage of errorMessages) {
                    repoSummary += ` - \`${errorMessage}\`\n`;

                    for (const error of errorMessageMap.get(errorMessage)!) {
                        repoSummary += `   - ${error.fileUrl ? makeMarkdownLink(error.fileUrl) : "Project Scope"}${oldProjectErrors.isComposite ? ` in ${makeMarkdownLink(error.projectUrl)}` : ``}\n`;
                    }
                }
            }

            if (sawNewRepoErrors) {
                // sawNewErrors = true;
                // summary += repoSummary;
                outputs.push(repoSummary)
                return true;
            }
        }
        catch (err) {
            reportError(err, "Error building " + repo.url ?? repo.name);
            return;
        }

        console.log("Done " + repo.url ?? repo.name);
    }
    finally {
        // Throw away the repo so we don't run out of space
        // Note that we specifically don't recover and attempt another repo if this fails
        console.log("Cleaning up repo");
        if (params.tmpfs) {
            await execAsync(processCwd, "sudo umount " + downloadDir);
            await reportResourceUsage(downloadDir);
        }
    }
}

export async function mainAsync(params: Params): Promise<git.Result | undefined> {
    const downloadDir = params.tmpfs ? "/mnt/ts_downloads" : "./ts_downloads";
    // TODO: check first whether the directory exists and skip downloading if possible
    // TODO: Seems like this should come after the typescript download
    if (params.tmpfs)
        await execAsync(processCwd, "sudo mkdir " + downloadDir);
    else
        await execAsync(processCwd, "mkdir " + downloadDir);

    // TODO: Only download if the commit has changed (need to map refs to commits and then download to typescript-COMMIT instead)
    const { oldTscPath, oldTscResolvedVersion, newTscPath, newTscResolvedVersion } = await downloadTypeScriptAsync(processCwd, params);

    // Get the name of the typescript folder.
    const oldTscDirPath = path.resolve(oldTscPath, "../../");
    const newTscDirPath = path.resolve(newTscPath, "../../");

    console.log("Old version = " + oldTscResolvedVersion);
    console.log("New version = " + newTscResolvedVersion);

    const userTestDir = path.join(processCwd, "userTests");

    const repos = ur.getUserTestsRepos(userTestDir);
    const outputs: string[] = [];
    // let summary = "";
    let sawNewErrors: true | undefined = undefined;

    let i = 0;
    const maxCount = Math.min(typeof params.repoCount === 'number' ? params.repoCount : Infinity, repos.length)

    for (const repo of repos) {
        if (repo.url && skipRepos.includes(repo.url)) continue;
        i++;
        if (i > maxCount) break;
        console.log(`Starting #${i} / ${maxCount}: ${repo.url ?? repo.name}`);
        sawNewErrors = sawNewErrors || await innerloop(params, downloadDir, userTestDir, repo, oldTscPath, newTscPath, outputs)
    }
    const summary = outputs.join("")

    if (params.tmpfs) {
        await execAsync(processCwd, "sudo rm -rf " + downloadDir);
        await execAsync(processCwd, "sudo rm -rf " + oldTscDirPath);
        await execAsync(processCwd, "sudo rm -rf " + newTscDirPath);
    }
    else {
        await execAsync(processCwd, "rm -rf " + downloadDir);
        await execAsync(processCwd, "rm -rf " + oldTscDirPath);
        await execAsync(processCwd, "rm -rf " + newTscDirPath);
    }

    const body = summary
        ? `@${params.requestingUser}\nThe results of the user tests run you requested are in!\n<details><summary> Here they are:</summary><p>\n<b>Comparison Report - ${oldTscResolvedVersion}..${newTscResolvedVersion}</b>\n\n${summary}</p></details>`
        : `@${params.requestingUser}\nGreat news! no new errors were found between ${oldTscResolvedVersion}..${newTscResolvedVersion}`;
    return git.createComment(params.sourceIssue, params.statusComment, params.postResult, body);
}

async function buildAndGetErrors(repoDir: string, tscPath: string, skipLibCheck: boolean, realTimeout: boolean): Promise<ge.RepoErrors> {
    if (realTimeout) {
        const p = new Promise<ge.RepoErrors>((resolve, reject) => {
            const p = cp.fork(path.join(__dirname, "run-build.js"));
            p.on('message', (m: 'ready' | ge.RepoErrors) =>
                m === 'ready'
                    ? p.send({ repoDir, tscPath, skipLibCheck })
                    : resolve(m));
            p.on('exit', reject);
        });
        return withTimeout(executionTimeout, p);
    }
    else {
        return ge.buildAndGetErrors(repoDir, tscPath, skipLibCheck)
    }
}

async function installPackages(repoDir: string, types?: string[]) {
    const commands = await ip.restorePackages(repoDir, types);
    let usedYarn = false;
    for (const { directory: packageRoot, tool, arguments: args } of commands) {
        await new Promise<void>((resolve, reject) => {
            usedYarn = usedYarn || tool === ip.InstallTool.Yarn;
            cp.execFile(tool, args, { cwd: packageRoot }, err => err ? reject(err) : resolve());
        });
    }
    if (usedYarn) {
        await execAsync(repoDir, "yarn cache clean --all");
    }
}

function withTimeout<T>(ms: number, promise: Promise<T>): Promise<T> {
    let timeout: NodeJS.Timeout | undefined;
    return Promise.race([
        promise.finally(() => timeout && clearTimeout(timeout)),
        new Promise<T>((_resolve, reject) =>
            timeout = setTimeout(async () => {
                await execAsync(processCwd, `./kill-children-of ${processPid} node`);
                return reject(new Error(`Timed out after ${ms} ms`));
            }, ms)),
    ]);
}

async function reportResourceUsage(downloadDir: string) {
    try {
        console.log("Memory");
        await execAsync(processCwd, "free -h");
        console.log("Disk");
        await execAsync(processCwd, "df -h");
        await execAsync(processCwd, "df -i");
        console.log("Download Directory");
        await execAsync(processCwd, "ls -lh " + downloadDir);
        console.log("Home Directory");
        await execAsync(processCwd, "du -csh ~/.[^.]*");
        await execAsync(processCwd, "du -csh ~/.cache/*");
    }
    catch { } // noop
}

export function reportError(err: any, message: string) {
    console.log(`${message}:`);
    console.log(reduceSpew(err.message ?? "No message").replace(/(^|\n)/g, "$1> "));
    console.log(reduceSpew(err.stack ?? "Unknown Stack").replace(/(^|\n)/g, "$1> "));
}

async function execAsync(cwd: string, command: string): Promise<string> {
    return new Promise((resolve, reject) => {
        console.log(`${cwd}> ${command}`);
        cp.exec(command, { cwd }, (err, stdout, stderr) => {
            if (stdout?.length) {
                console.log(stdout);
            }
            if (stderr?.length) {
                console.log(stderr); // To stdout to maintain order
            }

            if (err) {
                return reject(err);
            }
            return resolve(stdout);
        });
    });
}

function reduceSpew(message: string): string {
    // Since this is only a warning, it tends to be reported many (i.e. thousands of) times
    const problemString = "npm WARN tar ENOSPC: no space left on device, write\n";
    const index = message.indexOf(problemString);
    if (index < 0) return message;

    return message.substring(0, index) + problemString + replaceAll(message.substring(index), problemString, "");
}

function replaceAll(message: string, oldStr: string, newStr: string) {
    let result = "";
    let index = 0;
    while (true) {
        const newIndex = message.indexOf(oldStr, index);
        if (newIndex < 0) {
            return index === 0
                ? message
                : result + message.substring(index);
        }

        result += message.substring(index, newIndex);
        result += newStr;

        index = newIndex + oldStr.length;
    }
}

function makeMarkdownLink(url: string) {
    const match = /\/blob\/[a-f0-9]+\/(.+)$/.exec(url);
    return !match
        ? url
        : `[${match[1]}](${url})`;
}

async function downloadTypeScriptAsync(cwd: string, params: Params): Promise<{ oldTscPath: string, oldTscResolvedVersion: string, newTscPath: string, newTscResolvedVersion: string }> {
        const { tscPath: oldTscPath, resolvedVersion: oldTscResolvedVersion } = await downloadTypescriptRepoAsync(cwd, params.oldTypescriptRepoUrl, params.oldHeadRef);
        // We need to handle the ref/pull/*/merge differently as it is not a branch and cannot be pulled during clone.
        const { tscPath: newTscPath, resolvedVersion: newTscResolvedVersion } = await downloadTypescriptSourceIssueAsync(cwd, params.oldTypescriptRepoUrl, params.sourceIssue);

        return {
            oldTscPath,
            oldTscResolvedVersion,
            newTscPath,
            newTscResolvedVersion
        };
}

export async function downloadTypescriptRepoAsync(cwd: string, repoUrl: string, headRef: string): Promise<{ tscPath: string, resolvedVersion: string }> {
    const repoName = `typescript-${headRef}`;
    await git.cloneRepoIfNecessary(cwd, { name: repoName, url: repoUrl, branch: headRef });

    const repoPath = path.join(cwd, repoName);

    return {
        tscPath: await buildTsc(repoPath),
        resolvedVersion: headRef
    };
}

async function downloadTypescriptSourceIssueAsync(cwd: string, repoUrl: string, sourceIssue: number): Promise<{ tscPath: string, resolvedVersion: string }> {
    const repoName = `typescript-${sourceIssue}`;
    await git.cloneRepoIfNecessary(cwd, { name: repoName, url: repoUrl });

    const repoPath = path.join(cwd, repoName);
    const headRef = `refs/pull/${sourceIssue}/merge`;

    await git.checkout(repoPath, headRef);

    return {
        tscPath: await buildTsc(repoPath),
        resolvedVersion: headRef
    };
}

async function buildTsc(repoPath: string) {
    await execAsync(repoPath, "npm ci");
    await execAsync(repoPath, "npm run build:compiler");
    await execAsync(repoPath, "npm install -g gulp-cli");
    await execAsync(repoPath, "gulp configure-insiders");
    await execAsync(repoPath, "gulp LKG");
    return path.join(repoPath, "built", "local", "tsc.js");
}