+++ /dev/null
-'use strict';
-
-const Module = require('module');
-const crypto = require('crypto');
-const fs = require('fs');
-const path = require('path');
-const vm = require('vm');
-const os = require('os');
-
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-
-//------------------------------------------------------------------------------
-// FileSystemBlobStore
-//------------------------------------------------------------------------------
-
-class FileSystemBlobStore {
- constructor(directory, prefix) {
- const name = prefix ? slashEscape(prefix + '.') : '';
- this._blobFilename = path.join(directory, name + 'BLOB');
- this._mapFilename = path.join(directory, name + 'MAP');
- this._lockFilename = path.join(directory, name + 'LOCK');
- this._directory = directory;
- this._load();
- }
-
- has(key, invalidationKey) {
- if (hasOwnProperty.call(this._memoryBlobs, key)) {
- return this._invalidationKeys[key] === invalidationKey;
- } else if (hasOwnProperty.call(this._storedMap, key)) {
- return this._storedMap[key][0] === invalidationKey;
- }
- return false;
- }
-
- get(key, invalidationKey) {
- if (hasOwnProperty.call(this._memoryBlobs, key)) {
- if (this._invalidationKeys[key] === invalidationKey) {
- return this._memoryBlobs[key];
- }
- } else if (hasOwnProperty.call(this._storedMap, key)) {
- const mapping = this._storedMap[key];
- if (mapping[0] === invalidationKey) {
- return this._storedBlob.slice(mapping[1], mapping[2]);
- }
- }
- }
-
- set(key, invalidationKey, buffer) {
- this._invalidationKeys[key] = invalidationKey;
- this._memoryBlobs[key] = buffer;
- this._dirty = true;
- }
-
- delete(key) {
- if (hasOwnProperty.call(this._memoryBlobs, key)) {
- this._dirty = true;
- delete this._memoryBlobs[key];
- }
- if (hasOwnProperty.call(this._invalidationKeys, key)) {
- this._dirty = true;
- delete this._invalidationKeys[key];
- }
- if (hasOwnProperty.call(this._storedMap, key)) {
- this._dirty = true;
- delete this._storedMap[key];
- }
- }
-
- isDirty() {
- return this._dirty;
- }
-
- save() {
- const dump = this._getDump();
- const blobToStore = Buffer.concat(dump[0]);
- const mapToStore = JSON.stringify(dump[1]);
-
- try {
- mkdirpSync(this._directory);
- fs.writeFileSync(this._lockFilename, 'LOCK', {flag: 'wx'});
- } catch (error) {
- // Swallow the exception if we fail to acquire the lock.
- return false;
- }
-
- try {
- fs.writeFileSync(this._blobFilename, blobToStore);
- fs.writeFileSync(this._mapFilename, mapToStore);
- } finally {
- fs.unlinkSync(this._lockFilename);
- }
-
- return true;
- }
-
- _load() {
- try {
- this._storedBlob = fs.readFileSync(this._blobFilename);
- this._storedMap = JSON.parse(fs.readFileSync(this._mapFilename));
- } catch (e) {
- this._storedBlob = Buffer.alloc(0);
- this._storedMap = {};
- }
- this._dirty = false;
- this._memoryBlobs = {};
- this._invalidationKeys = {};
- }
-
- _getDump() {
- const buffers = [];
- const newMap = {};
- let offset = 0;
-
- function push(key, invalidationKey, buffer) {
- buffers.push(buffer);
- newMap[key] = [invalidationKey, offset, offset + buffer.length];
- offset += buffer.length;
- }
-
- for (const key of Object.keys(this._memoryBlobs)) {
- const buffer = this._memoryBlobs[key];
- const invalidationKey = this._invalidationKeys[key];
- push(key, invalidationKey, buffer);
- }
-
- for (const key of Object.keys(this._storedMap)) {
- if (hasOwnProperty.call(newMap, key)) continue;
- const mapping = this._storedMap[key];
- const buffer = this._storedBlob.slice(mapping[1], mapping[2]);
- push(key, mapping[0], buffer);
- }
-
- return [buffers, newMap];
- }
-}
-
-//------------------------------------------------------------------------------
-// NativeCompileCache
-//------------------------------------------------------------------------------
-
-class NativeCompileCache {
- constructor() {
- this._cacheStore = null;
- this._previousModuleCompile = null;
- }
-
- setCacheStore(cacheStore) {
- this._cacheStore = cacheStore;
- }
-
- install() {
- const self = this;
- const hasRequireResolvePaths = typeof require.resolve.paths === 'function';
- this._previousModuleCompile = Module.prototype._compile;
- Module.prototype._compile = function(content, filename) {
- const mod = this;
-
- function require(id) {
- return mod.require(id);
- }
-
- // https://github.com/nodejs/node/blob/v10.15.3/lib/internal/modules/cjs/helpers.js#L28
- function resolve(request, options) {
- return Module._resolveFilename(request, mod, false, options);
- }
- require.resolve = resolve;
-
- // https://github.com/nodejs/node/blob/v10.15.3/lib/internal/modules/cjs/helpers.js#L37
- // resolve.resolve.paths was added in v8.9.0
- if (hasRequireResolvePaths) {
- resolve.paths = function paths(request) {
- return Module._resolveLookupPaths(request, mod, true);
- };
- }
-
- require.main = process.mainModule;
-
- // Enable support to add extra extension types
- require.extensions = Module._extensions;
- require.cache = Module._cache;
-
- const dirname = path.dirname(filename);
-
- const compiledWrapper = self._moduleCompile(filename, content);
-
- // We skip the debugger setup because by the time we run, node has already
- // done that itself.
-
- // `Buffer` is included for Electron.
- // See https://github.com/zertosh/v8-compile-cache/pull/10#issuecomment-518042543
- const args = [mod.exports, require, mod, filename, dirname, process, global, Buffer];
- return compiledWrapper.apply(mod.exports, args);
- };
- }
-
- uninstall() {
- Module.prototype._compile = this._previousModuleCompile;
- }
-
- _moduleCompile(filename, content) {
- // https://github.com/nodejs/node/blob/v7.5.0/lib/module.js#L511
-
- // Remove shebang
- var contLen = content.length;
- if (contLen >= 2) {
- if (content.charCodeAt(0) === 35/*#*/ &&
- content.charCodeAt(1) === 33/*!*/) {
- if (contLen === 2) {
- // Exact match
- content = '';
- } else {
- // Find end of shebang line and slice it off
- var i = 2;
- for (; i < contLen; ++i) {
- var code = content.charCodeAt(i);
- if (code === 10/*\n*/ || code === 13/*\r*/) break;
- }
- if (i === contLen) {
- content = '';
- } else {
- // Note that this actually includes the newline character(s) in the
- // new output. This duplicates the behavior of the regular
- // expression that was previously used to replace the shebang line
- content = content.slice(i);
- }
- }
- }
- }
-
- // create wrapper function
- var wrapper = Module.wrap(content);
-
- var invalidationKey = crypto
- .createHash('sha1')
- .update(content, 'utf8')
- .digest('hex');
-
- var buffer = this._cacheStore.get(filename, invalidationKey);
-
- var script = new vm.Script(wrapper, {
- filename: filename,
- lineOffset: 0,
- displayErrors: true,
- cachedData: buffer,
- produceCachedData: true,
- });
-
- if (script.cachedDataProduced) {
- this._cacheStore.set(filename, invalidationKey, script.cachedData);
- } else if (script.cachedDataRejected) {
- this._cacheStore.delete(filename);
- }
-
- var compiledWrapper = script.runInThisContext({
- filename: filename,
- lineOffset: 0,
- columnOffset: 0,
- displayErrors: true,
- });
-
- return compiledWrapper;
- }
-}
-
-//------------------------------------------------------------------------------
-// utilities
-//
-// https://github.com/substack/node-mkdirp/blob/f2003bb/index.js#L55-L98
-// https://github.com/zertosh/slash-escape/blob/e7ebb99/slash-escape.js
-//------------------------------------------------------------------------------
-
-function mkdirpSync(p_) {
- _mkdirpSync(path.resolve(p_), 0o777);
-}
-
-function _mkdirpSync(p, mode) {
- try {
- fs.mkdirSync(p, mode);
- } catch (err0) {
- if (err0.code === 'ENOENT') {
- _mkdirpSync(path.dirname(p));
- _mkdirpSync(p);
- } else {
- try {
- const stat = fs.statSync(p);
- if (!stat.isDirectory()) { throw err0; }
- } catch (err1) {
- throw err0;
- }
- }
- }
-}
-
-function slashEscape(str) {
- const ESCAPE_LOOKUP = {
- '\\': 'zB',
- ':': 'zC',
- '/': 'zS',
- '\x00': 'z0',
- 'z': 'zZ',
- };
- const ESCAPE_REGEX = /[\\:/\x00z]/g; // eslint-disable-line no-control-regex
- return str.replace(ESCAPE_REGEX, match => ESCAPE_LOOKUP[match]);
-}
-
-function supportsCachedData() {
- const script = new vm.Script('""', {produceCachedData: true});
- // chakracore, as of v1.7.1.0, returns `false`.
- return script.cachedDataProduced === true;
-}
-
-function getCacheDir() {
- const v8_compile_cache_cache_dir = process.env.V8_COMPILE_CACHE_CACHE_DIR;
- if (v8_compile_cache_cache_dir) {
- return v8_compile_cache_cache_dir;
- }
-
- // Avoid cache ownership issues on POSIX systems.
- const dirname = typeof process.getuid === 'function'
- ? 'v8-compile-cache-' + process.getuid()
- : 'v8-compile-cache';
- const version = typeof process.versions.v8 === 'string'
- ? process.versions.v8
- : typeof process.versions.chakracore === 'string'
- ? 'chakracore-' + process.versions.chakracore
- : 'node-' + process.version;
- const cacheDir = path.join(os.tmpdir(), dirname, version);
- return cacheDir;
-}
-
-function getParentName() {
- // `module.parent.filename` is undefined or null when:
- // * node -e 'require("v8-compile-cache")'
- // * node -r 'v8-compile-cache'
- // * Or, requiring from the REPL.
- const parentName = module.parent && typeof module.parent.filename === 'string'
- ? module.parent.filename
- : process.cwd();
- return parentName;
-}
-
-//------------------------------------------------------------------------------
-// main
-//------------------------------------------------------------------------------
-
-if (!process.env.DISABLE_V8_COMPILE_CACHE && supportsCachedData()) {
- const cacheDir = getCacheDir();
- const prefix = getParentName();
- const blobStore = new FileSystemBlobStore(cacheDir, prefix);
-
- const nativeCompileCache = new NativeCompileCache();
- nativeCompileCache.setCacheStore(blobStore);
- nativeCompileCache.install();
-
- process.once('exit', () => {
- if (blobStore.isDirty()) {
- blobStore.save();
- }
- nativeCompileCache.uninstall();
- });
-}
-
-module.exports.__TEST__ = {
- FileSystemBlobStore,
- NativeCompileCache,
- mkdirpSync,
- slashEscape,
- supportsCachedData,
- getCacheDir,
- getParentName,
-};
projects / dotfiles / .git / blobdiff