Method cacheOpen

packages/hydrojudge/src/task.ts:118–168

(source: string, files: FileInfo[])

    }

    async cacheOpen(source: string, files: FileInfo[]) {
        // Backward compatibility for vj4
        if ((this.session as any).cacheOpen) return (this.session as any).cacheOpen(source, files);
        using span = this.startChildSpan('judge.cacheOpen', { source, fileCount: files?.length || 0 });
        const host = this.session.config?.host || 'local';
        const filePath = join(getConfig('cache_dir'), host, source);
        await Lock.acquire(filePath);
        try {
            await fs.ensureDir(filePath);
            if (!files?.length) throw new FormatError('Problem data not found.');
            let etags: Record<string, string> = {};
            try {
                etags = JSON.parse(await fs.readFile(join(filePath, 'etags'), 'utf-8'));
            } catch (e) { /* ignore */ }
            this.compileCache = etags['*cache'] as any || {};
            delete etags['*cache'];
            const version = {};
            const filenames = [];
            const allFiles = new Set<string>();
            for (const file of files) {
                allFiles.add(file.name);
                version[file.name] = file.etag + file.lastModified;
                if (etags[file.name] !== file.etag + file.lastModified) filenames.push(file.name);
            }
            const allFilesToRemove = Object.keys(etags).filter((name) => !allFiles.has(name) && fs.existsSync(join(filePath, name)));
            await Promise.all(allFilesToRemove.map((name) => fs.remove(join(filePath, name))));
            if (filenames.length) {
                span.setAttribute('files', filenames);
                logger.info(`Getting problem data: ${this.session?.config.host || 'local'}/${source}`);
                this.next({ message: 'Syncing testdata, please wait...' });
                this.mainContext = trace.setSpan(context.active(), span);
                await this.session.fetchFile(source, Object.fromEntries(
                    files.filter((i) => filenames.includes(i.name))
                        .map((i) => [i.name, join(filePath, i.name)]),
                ), this);
                this.compileCache = {};
            }
            if (allFilesToRemove.length || filenames.length) {
                await fs.writeFile(join(filePath, 'etags'), JSON.stringify(version));
            }
            await fs.writeFile(join(filePath, 'lastUsage'), Date.now().toString());
            return filePath;
        } catch (e) {
            span.recordException(e);
            logger.warn('CacheOpen Fail: %s %o %o', source, files, e);
            throw e;
        } finally {
            this.mainContext = trace.setSpan(context.active(), this.span);
            Lock.release(filePath);
        }
    }

    async doSubmission() {
        this.folder = await this.cacheOpen(this.source, this.data);