| /* |
| MIT License http://www.opensource.org/licenses/mit-license.php |
| Author Tobias Koppers @sokra |
| */ |
| "use strict"; |
| |
| class Storage { |
| constructor(duration) { |
| this.duration = duration; |
| this.running = new Map(); |
| this.data = new Map(); |
| this.levels = []; |
| if (duration > 0) { |
| this.levels.push( |
| new Set(), |
| new Set(), |
| new Set(), |
| new Set(), |
| new Set(), |
| new Set(), |
| new Set(), |
| new Set(), |
| new Set() |
| ); |
| for (let i = 8000; i < duration; i += 500) this.levels.push(new Set()); |
| } |
| this.count = 0; |
| this.interval = null; |
| this.needTickCheck = false; |
| this.nextTick = null; |
| this.passive = true; |
| this.tick = this.tick.bind(this); |
| } |
| |
| ensureTick() { |
| if (!this.interval && this.duration > 0 && !this.nextTick) |
| this.interval = setInterval( |
| this.tick, |
| Math.floor(this.duration / this.levels.length) |
| ); |
| } |
| |
| finished(name, err, result) { |
| const callbacks = this.running.get(name); |
| this.running.delete(name); |
| if (this.duration > 0) { |
| this.data.set(name, [err, result]); |
| const levelData = this.levels[0]; |
| this.count -= levelData.size; |
| levelData.add(name); |
| this.count += levelData.size; |
| this.ensureTick(); |
| } |
| for (let i = 0; i < callbacks.length; i++) { |
| callbacks[i](err, result); |
| } |
| } |
| |
| finishedSync(name, err, result) { |
| if (this.duration > 0) { |
| this.data.set(name, [err, result]); |
| const levelData = this.levels[0]; |
| this.count -= levelData.size; |
| levelData.add(name); |
| this.count += levelData.size; |
| this.ensureTick(); |
| } |
| } |
| |
| provide(name, provider, callback) { |
| if (typeof name !== "string") { |
| callback(new TypeError("path must be a string")); |
| return; |
| } |
| let running = this.running.get(name); |
| if (running) { |
| running.push(callback); |
| return; |
| } |
| if (this.duration > 0) { |
| this.checkTicks(); |
| const data = this.data.get(name); |
| if (data) { |
| return process.nextTick(() => { |
| callback.apply(null, data); |
| }); |
| } |
| } |
| this.running.set(name, (running = [callback])); |
| provider(name, (err, result) => { |
| this.finished(name, err, result); |
| }); |
| } |
| |
| provideSync(name, provider) { |
| if (typeof name !== "string") { |
| throw new TypeError("path must be a string"); |
| } |
| if (this.duration > 0) { |
| this.checkTicks(); |
| const data = this.data.get(name); |
| if (data) { |
| if (data[0]) throw data[0]; |
| return data[1]; |
| } |
| } |
| let result; |
| try { |
| result = provider(name); |
| } catch (e) { |
| this.finishedSync(name, e); |
| throw e; |
| } |
| this.finishedSync(name, null, result); |
| return result; |
| } |
| |
| tick() { |
| const decay = this.levels.pop(); |
| for (let item of decay) { |
| this.data.delete(item); |
| } |
| this.count -= decay.size; |
| decay.clear(); |
| this.levels.unshift(decay); |
| if (this.count === 0) { |
| clearInterval(this.interval); |
| this.interval = null; |
| this.nextTick = null; |
| return true; |
| } else if (this.nextTick) { |
| this.nextTick += Math.floor(this.duration / this.levels.length); |
| const time = new Date().getTime(); |
| if (this.nextTick > time) { |
| this.nextTick = null; |
| this.interval = setInterval( |
| this.tick, |
| Math.floor(this.duration / this.levels.length) |
| ); |
| return true; |
| } |
| } else if (this.passive) { |
| clearInterval(this.interval); |
| this.interval = null; |
| this.nextTick = |
| new Date().getTime() + Math.floor(this.duration / this.levels.length); |
| } else { |
| this.passive = true; |
| } |
| } |
| |
| checkTicks() { |
| this.passive = false; |
| if (this.nextTick) { |
| while (!this.tick()); |
| } |
| } |
| |
| purge(what) { |
| if (!what) { |
| this.count = 0; |
| clearInterval(this.interval); |
| this.nextTick = null; |
| this.data.clear(); |
| this.levels.forEach(level => { |
| level.clear(); |
| }); |
| } else if (typeof what === "string") { |
| for (let key of this.data.keys()) { |
| if (key.startsWith(what)) this.data.delete(key); |
| } |
| } else { |
| for (let i = what.length - 1; i >= 0; i--) { |
| this.purge(what[i]); |
| } |
| } |
| } |
| } |
| |
| module.exports = class CachedInputFileSystem { |
| constructor(fileSystem, duration) { |
| this.fileSystem = fileSystem; |
| this._statStorage = new Storage(duration); |
| this._readdirStorage = new Storage(duration); |
| this._readFileStorage = new Storage(duration); |
| this._readJsonStorage = new Storage(duration); |
| this._readlinkStorage = new Storage(duration); |
| |
| this._stat = this.fileSystem.stat |
| ? this.fileSystem.stat.bind(this.fileSystem) |
| : null; |
| if (!this._stat) this.stat = null; |
| |
| this._statSync = this.fileSystem.statSync |
| ? this.fileSystem.statSync.bind(this.fileSystem) |
| : null; |
| if (!this._statSync) this.statSync = null; |
| |
| this._readdir = this.fileSystem.readdir |
| ? this.fileSystem.readdir.bind(this.fileSystem) |
| : null; |
| if (!this._readdir) this.readdir = null; |
| |
| this._readdirSync = this.fileSystem.readdirSync |
| ? this.fileSystem.readdirSync.bind(this.fileSystem) |
| : null; |
| if (!this._readdirSync) this.readdirSync = null; |
| |
| this._readFile = this.fileSystem.readFile |
| ? this.fileSystem.readFile.bind(this.fileSystem) |
| : null; |
| if (!this._readFile) this.readFile = null; |
| |
| this._readFileSync = this.fileSystem.readFileSync |
| ? this.fileSystem.readFileSync.bind(this.fileSystem) |
| : null; |
| if (!this._readFileSync) this.readFileSync = null; |
| |
| if (this.fileSystem.readJson) { |
| this._readJson = this.fileSystem.readJson.bind(this.fileSystem); |
| } else if (this.readFile) { |
| this._readJson = (path, callback) => { |
| this.readFile(path, (err, buffer) => { |
| if (err) return callback(err); |
| let data; |
| try { |
| data = JSON.parse(buffer.toString("utf-8")); |
| } catch (e) { |
| return callback(e); |
| } |
| callback(null, data); |
| }); |
| }; |
| } else { |
| this.readJson = null; |
| } |
| if (this.fileSystem.readJsonSync) { |
| this._readJsonSync = this.fileSystem.readJsonSync.bind(this.fileSystem); |
| } else if (this.readFileSync) { |
| this._readJsonSync = path => { |
| const buffer = this.readFileSync(path); |
| const data = JSON.parse(buffer.toString("utf-8")); |
| return data; |
| }; |
| } else { |
| this.readJsonSync = null; |
| } |
| |
| this._readlink = this.fileSystem.readlink |
| ? this.fileSystem.readlink.bind(this.fileSystem) |
| : null; |
| if (!this._readlink) this.readlink = null; |
| |
| this._readlinkSync = this.fileSystem.readlinkSync |
| ? this.fileSystem.readlinkSync.bind(this.fileSystem) |
| : null; |
| if (!this._readlinkSync) this.readlinkSync = null; |
| } |
| |
| stat(path, callback) { |
| this._statStorage.provide(path, this._stat, callback); |
| } |
| |
| readdir(path, callback) { |
| this._readdirStorage.provide(path, this._readdir, callback); |
| } |
| |
| readFile(path, callback) { |
| this._readFileStorage.provide(path, this._readFile, callback); |
| } |
| |
| readJson(path, callback) { |
| this._readJsonStorage.provide(path, this._readJson, callback); |
| } |
| |
| readlink(path, callback) { |
| this._readlinkStorage.provide(path, this._readlink, callback); |
| } |
| |
| statSync(path) { |
| return this._statStorage.provideSync(path, this._statSync); |
| } |
| |
| readdirSync(path) { |
| return this._readdirStorage.provideSync(path, this._readdirSync); |
| } |
| |
| readFileSync(path) { |
| return this._readFileStorage.provideSync(path, this._readFileSync); |
| } |
| |
| readJsonSync(path) { |
| return this._readJsonStorage.provideSync(path, this._readJsonSync); |
| } |
| |
| readlinkSync(path) { |
| return this._readlinkStorage.provideSync(path, this._readlinkSync); |
| } |
| |
| purge(what) { |
| this._statStorage.purge(what); |
| this._readdirStorage.purge(what); |
| this._readFileStorage.purge(what); |
| this._readlinkStorage.purge(what); |
| this._readJsonStorage.purge(what); |
| } |
| }; |