Method execCompilerCached

lib/base-compiler.ts:445–506

(
        compiler: string,
        args: string[],
        options?: ExecutionOptionsWithEnv,
    )

    }

    public async execCompilerCached(
        compiler: string,
        args: string[],
        options?: ExecutionOptionsWithEnv,
    ): Promise<UnprocessedExecResult> {
        if (this.mtime === null) {
            throw new Error('Attempt to access cached compiler before initialise() called');
        }

        if (!options) {
            options = this.getDefaultExecOptions();
            options.timeoutMs = 0;
            options.ldPath = this.getSharedLibraryPathsAsLdLibraryPaths([]);
        }

        // Take a (shallow) copy of the options before we add a random customCwd: The fact we have createAndUseTempDir
        // set is enough to make us different from an otherwise identical run without createAndUseTempDir. However, the
        // actual random path is unimportant for caching; and its presence prevents cache hits.
        const optionsForCache = {...options};
        if (options.createAndUseTempDir) {
            options.customCwd = await this.newTempDir();
        }

        const key = this.getCompilerCacheKey(compiler, args, optionsForCache);
        const hash = BaseCache.hash(key);

        let result = await this.env.compilerCacheGet(key);
        if (result) {
            if (exec.hasNsjailPermissionsIssue(result)) {
                logger.info(`Throwing out faulty cached result with nsjail permissions issue for ${compiler}`);
                result = undefined;
            }
        }

        if (!result && this.env.willBeInCacheSoon(hash)) {
            result = await this.env.enqueue(async () => {
                return await this.env.compilerCacheGet(key);
            });
        }

        if (!result) {
            this.env.setCachingInProgress(hash);
            result = await this.env.enqueue(async () => {
                const res = await this.exec(compiler, args, options);
                if (res.okToCache) {
                    try {
                        await this.env.compilerCachePut(key, res, undefined);
                    } catch (e) {
                        logger.info('Uncaught exception caching compilation results', e);
                    }
                }
                this.env.clearCachingInProgress(hash);
                return res;
            });
        }

        if (options.createAndUseTempDir) {
            fs.rm(options.customCwd!, {recursive: true, force: true}).catch(() => {});