| 'use strict'; |
| |
| const fs = require('fs'); |
| const sysPath = require('path'); |
| const isBinaryPath = require('is-binary-path'); |
| const { promisify } = require('util'); |
| const { |
| isWindows, |
| EMPTY_FN, |
| EMPTY_STR, |
| KEY_LISTENERS, |
| KEY_ERR, |
| KEY_RAW, |
| HANDLER_KEYS, |
| EV_CHANGE, |
| EV_ADD, |
| EV_ADD_DIR, |
| EV_ERROR, |
| STR_DATA, |
| STR_END |
| } = require('./constants'); |
| |
| const THROTTLE_MODE_WATCH = 'watch'; |
| |
| const open = promisify(fs.open); |
| const stat = promisify(fs.stat); |
| const lstat = promisify(fs.lstat); |
| const close = promisify(fs.close); |
| const fsrealpath = promisify(fs.realpath); |
| |
| const statMethods = { lstat, stat }; |
| |
| // TODO: emit errors properly. Example: EMFILE on Macos. |
| const foreach = (val, fn) => { |
| if (val instanceof Set) { |
| val.forEach(fn); |
| } else { |
| fn(val); |
| } |
| }; |
| |
| const addAndConvert = (main, prop, item) => { |
| let container = main[prop]; |
| if (!(container instanceof Set)) { |
| main[prop] = container = new Set([container]); |
| } |
| container.add(item); |
| }; |
| |
| const clearItem = cont => key => { |
| const set = cont[key]; |
| if (set instanceof Set) { |
| set.clear(); |
| } else { |
| delete cont[key]; |
| } |
| }; |
| |
| const delFromSet = (main, prop, item) => { |
| const container = main[prop]; |
| if (!(container instanceof Set)) { |
| if (container === item) delete main[prop]; |
| } else { |
| container.delete(item); |
| } |
| }; |
| |
| const isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val; |
| |
| /** |
| * @typedef {String} Path |
| */ |
| |
| // fs_watch helpers |
| |
| // object to hold per-process fs_watch instances |
| // (may be shared across chokidar FSWatcher instances) |
| |
| /** |
| * @typedef {Object} FsWatchContainer |
| * @property {Set} listeners |
| * @property {Set} errHandlers |
| * @property {Set} rawEmitters |
| * @property {fs.FSWatcher=} watcher |
| * @property {Boolean=} watcherUnusable |
| */ |
| |
| /** |
| * @type {Map<String,FsWatchContainer>} |
| */ |
| const FsWatchInstances = new Map(); |
| |
| /** |
| * Instantiates the fs_watch interface |
| * @param {String} path to be watched |
| * @param {Object} options to be passed to fs_watch |
| * @param {Function} listener main event handler |
| * @param {Function} errHandler emits info about errors |
| * @param {Function} emitRaw emits raw event data |
| * @returns {fs.FSWatcher} new fsevents instance |
| */ |
| function createFsWatchInstance(path, options, listener, errHandler, emitRaw) { |
| const handleEvent = (rawEvent, evPath) => { |
| listener(path); |
| emitRaw(rawEvent, evPath, {watchedPath: path}); |
| |
| // emit based on events occurring for files from a directory's watcher in |
| // case the file's watcher misses it (and rely on throttling to de-dupe) |
| if (evPath && path !== evPath) { |
| fsWatchBroadcast( |
| sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath) |
| ); |
| } |
| }; |
| try { |
| return fs.watch(path, options, handleEvent); |
| } catch (error) { |
| errHandler(error); |
| } |
| } |
| |
| /** |
| * Helper for passing fs_watch event data to a collection of listeners |
| * @param {Path} fullPath absolute path bound to fs_watch instance |
| * @param {String} type listener type |
| * @param {*=} val1 arguments to be passed to listeners |
| * @param {*=} val2 |
| * @param {*=} val3 |
| */ |
| const fsWatchBroadcast = (fullPath, type, val1, val2, val3) => { |
| const cont = FsWatchInstances.get(fullPath); |
| if (!cont) return; |
| foreach(cont[type], (listener) => { |
| listener(val1, val2, val3); |
| }); |
| }; |
| |
| /** |
| * Instantiates the fs_watch interface or binds listeners |
| * to an existing one covering the same file system entry |
| * @param {String} path |
| * @param {String} fullPath absolute path |
| * @param {Object} options to be passed to fs_watch |
| * @param {Object} handlers container for event listener functions |
| */ |
| const setFsWatchListener = (path, fullPath, options, handlers) => { |
| const {listener, errHandler, rawEmitter} = handlers; |
| let cont = FsWatchInstances.get(fullPath); |
| |
| /** @type {fs.FSWatcher=} */ |
| let watcher; |
| if (!options.persistent) { |
| watcher = createFsWatchInstance( |
| path, options, listener, errHandler, rawEmitter |
| ); |
| return watcher.close.bind(watcher); |
| } |
| if (cont) { |
| addAndConvert(cont, KEY_LISTENERS, listener); |
| addAndConvert(cont, KEY_ERR, errHandler); |
| addAndConvert(cont, KEY_RAW, rawEmitter); |
| } else { |
| watcher = createFsWatchInstance( |
| path, |
| options, |
| fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), |
| errHandler, // no need to use broadcast here |
| fsWatchBroadcast.bind(null, fullPath, KEY_RAW) |
| ); |
| if (!watcher) return; |
| watcher.on(EV_ERROR, async (error) => { |
| const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR); |
| cont.watcherUnusable = true; // documented since Node 10.4.1 |
| // Workaround for https://github.com/joyent/node/issues/4337 |
| if (isWindows && error.code === 'EPERM') { |
| try { |
| const fd = await open(path, 'r'); |
| await close(fd); |
| broadcastErr(error); |
| } catch (err) {} |
| } else { |
| broadcastErr(error); |
| } |
| }); |
| cont = { |
| listeners: listener, |
| errHandlers: errHandler, |
| rawEmitters: rawEmitter, |
| watcher: watcher |
| }; |
| FsWatchInstances.set(fullPath, cont); |
| } |
| // const index = cont.listeners.indexOf(listener); |
| |
| // removes this instance's listeners and closes the underlying fs_watch |
| // instance if there are no more listeners left |
| return () => { |
| delFromSet(cont, KEY_LISTENERS, listener); |
| delFromSet(cont, KEY_ERR, errHandler); |
| delFromSet(cont, KEY_RAW, rawEmitter); |
| if (isEmptySet(cont.listeners)) { |
| // Check to protect against issue gh-730. |
| // if (cont.watcherUnusable) { |
| cont.watcher.close(); |
| // } |
| FsWatchInstances.delete(fullPath); |
| HANDLER_KEYS.forEach(clearItem(cont)); |
| cont.watcher = undefined; |
| Object.freeze(cont); |
| } |
| }; |
| }; |
| |
| // fs_watchFile helpers |
| |
| // object to hold per-process fs_watchFile instances |
| // (may be shared across chokidar FSWatcher instances) |
| const FsWatchFileInstances = new Map(); |
| |
| /** |
| * Instantiates the fs_watchFile interface or binds listeners |
| * to an existing one covering the same file system entry |
| * @param {String} path to be watched |
| * @param {String} fullPath absolute path |
| * @param {Object} options options to be passed to fs_watchFile |
| * @param {Object} handlers container for event listener functions |
| * @returns {Function} closer |
| */ |
| const setFsWatchFileListener = (path, fullPath, options, handlers) => { |
| const listener = handlers.listener; |
| const rawEmitter = handlers.rawEmitter; |
| let cont = FsWatchFileInstances.get(fullPath); |
| let listeners = new Set(); |
| let rawEmitters = new Set(); |
| |
| const copts = cont && cont.options; |
| if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) { |
| // "Upgrade" the watcher to persistence or a quicker interval. |
| // This creates some unlikely edge case issues if the user mixes |
| // settings in a very weird way, but solving for those cases |
| // doesn't seem worthwhile for the added complexity. |
| listeners = cont.listeners; |
| rawEmitters = cont.rawEmitters; |
| fs.unwatchFile(fullPath); |
| cont = undefined; |
| } |
| |
| if (cont) { |
| addAndConvert(cont, KEY_LISTENERS, listener); |
| addAndConvert(cont, KEY_RAW, rawEmitter); |
| } else { |
| // TODO |
| // listeners.add(listener); |
| // rawEmitters.add(rawEmitter); |
| cont = { |
| listeners: listener, |
| rawEmitters: rawEmitter, |
| options: options, |
| watcher: fs.watchFile(fullPath, options, (curr, prev) => { |
| foreach(cont.rawEmitters, (rawEmitter) => { |
| rawEmitter(EV_CHANGE, fullPath, {curr, prev}); |
| }); |
| const currmtime = curr.mtimeMs; |
| if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) { |
| foreach(cont.listeners, (listener) => listener(path, curr)); |
| } |
| }) |
| }; |
| FsWatchFileInstances.set(fullPath, cont); |
| } |
| // const index = cont.listeners.indexOf(listener); |
| |
| // Removes this instance's listeners and closes the underlying fs_watchFile |
| // instance if there are no more listeners left. |
| return () => { |
| delFromSet(cont, KEY_LISTENERS, listener); |
| delFromSet(cont, KEY_RAW, rawEmitter); |
| if (isEmptySet(cont.listeners)) { |
| FsWatchFileInstances.delete(fullPath); |
| fs.unwatchFile(fullPath); |
| cont.options = cont.watcher = undefined; |
| Object.freeze(cont); |
| } |
| }; |
| }; |
| |
| /** |
| * @mixin |
| */ |
| class NodeFsHandler { |
| |
| /** |
| * @param {import("../index").FSWatcher} fsW |
| */ |
| constructor(fsW) { |
| this.fsw = fsW; |
| this._boundHandleError = (error) => fsW._handleError(error); |
| } |
| |
| /** |
| * Watch file for changes with fs_watchFile or fs_watch. |
| * @param {String} path to file or dir |
| * @param {Function} listener on fs change |
| * @returns {Function} closer for the watcher instance |
| */ |
| _watchWithNodeFs(path, listener) { |
| const opts = this.fsw.options; |
| const directory = sysPath.dirname(path); |
| const basename = sysPath.basename(path); |
| const parent = this.fsw._getWatchedDir(directory); |
| parent.add(basename); |
| const absolutePath = sysPath.resolve(path); |
| const options = {persistent: opts.persistent}; |
| if (!listener) listener = EMPTY_FN; |
| |
| let closer; |
| if (opts.usePolling) { |
| options.interval = opts.enableBinaryInterval && isBinaryPath(basename) ? |
| opts.binaryInterval : opts.interval; |
| closer = setFsWatchFileListener(path, absolutePath, options, { |
| listener: listener, |
| rawEmitter: this.fsw._emitRaw |
| }); |
| } else { |
| closer = setFsWatchListener(path, absolutePath, options, { |
| listener: listener, |
| errHandler: this._boundHandleError, |
| rawEmitter: this.fsw._emitRaw |
| }); |
| } |
| return closer; |
| } |
| |
| /** |
| * Watch a file and emit add event if warranted. |
| * @param {Path} file Path |
| * @param {fs.Stats} stats result of fs_stat |
| * @param {Boolean} initialAdd was the file added at watch instantiation? |
| * @returns {Function} closer for the watcher instance |
| */ |
| _handleFile(file, stats, initialAdd) { |
| if (this.fsw.closed) { |
| return; |
| } |
| const dirname = sysPath.dirname(file); |
| const basename = sysPath.basename(file); |
| const parent = this.fsw._getWatchedDir(dirname); |
| // stats is always present |
| let prevStats = stats; |
| |
| // if the file is already being watched, do nothing |
| if (parent.has(basename)) return; |
| |
| // kick off the watcher |
| const closer = this._watchWithNodeFs(file, async (path, newStats) => { |
| if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return; |
| if (!newStats || newStats && newStats.mtimeMs === 0) { |
| try { |
| const newStats = await stat(file); |
| if (this.fsw.closed) return; |
| // Check that change event was not fired because of changed only accessTime. |
| const at = newStats.atimeMs; |
| const mt = newStats.mtimeMs; |
| if (!at || at <= mt || mt !== prevStats.mtimeMs) { |
| this.fsw._emit(EV_CHANGE, file, newStats); |
| } |
| prevStats = newStats; |
| } catch (error) { |
| // Fix issues where mtime is null but file is still present |
| this.fsw._remove(dirname, basename); |
| } |
| // add is about to be emitted if file not already tracked in parent |
| } else if (parent.has(basename)) { |
| // Check that change event was not fired because of changed only accessTime. |
| const at = newStats.atimeMs; |
| const mt = newStats.mtimeMs; |
| if (!at || at <= mt || mt !== prevStats.mtimeMs) { |
| this.fsw._emit(EV_CHANGE, file, newStats); |
| } |
| prevStats = newStats; |
| } |
| }); |
| |
| // emit an add event if we're supposed to |
| if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) { |
| if (!this.fsw._throttle(EV_ADD, file, 0)) return; |
| this.fsw._emit(EV_ADD, file, stats); |
| } |
| |
| return closer; |
| } |
| |
| /** |
| * Handle symlinks encountered while reading a dir. |
| * @param {Object} entry returned by readdirp |
| * @param {String} directory path of dir being read |
| * @param {String} path of this item |
| * @param {String} item basename of this item |
| * @returns {Promise<Boolean>} true if no more processing is needed for this entry. |
| */ |
| async _handleSymlink(entry, directory, path, item) { |
| if (this.fsw.closed) { |
| return; |
| } |
| const full = entry.fullPath; |
| const dir = this.fsw._getWatchedDir(directory); |
| |
| if (!this.fsw.options.followSymlinks) { |
| // watch symlink directly (don't follow) and detect changes |
| this.fsw._incrReadyCount(); |
| const linkPath = await fsrealpath(path); |
| if (this.fsw.closed) return; |
| if (dir.has(item)) { |
| if (this.fsw._symlinkPaths.get(full) !== linkPath) { |
| this.fsw._symlinkPaths.set(full, linkPath); |
| this.fsw._emit(EV_CHANGE, path, entry.stats); |
| } |
| } else { |
| dir.add(item); |
| this.fsw._symlinkPaths.set(full, linkPath); |
| this.fsw._emit(EV_ADD, path, entry.stats); |
| } |
| this.fsw._emitReady(); |
| return true; |
| } |
| |
| // don't follow the same symlink more than once |
| if (this.fsw._symlinkPaths.has(full)) { |
| return true; |
| } else { |
| this.fsw._symlinkPaths.set(full, true); |
| } |
| } |
| |
| _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) { |
| // Normalize the directory name on Windows |
| directory = sysPath.join(directory, EMPTY_STR); |
| |
| if (!wh.hasGlob) { |
| // throttler = this.fsw._throttle('readdir', directory, 1000); |
| // if (!throttler) return; |
| } |
| |
| const previous = this.fsw._getWatchedDir(wh.path); |
| const current = new Set(); |
| |
| let stream = this.fsw._readdirp(directory, { |
| fileFilter: entry => wh.filterPath(entry), |
| directoryFilter: entry => wh.filterDir(entry), |
| depth: 0, |
| }).on(STR_DATA, async (entry) => { |
| if (this.fsw.closed) { |
| stream = undefined; |
| return; |
| } |
| const item = entry.path; |
| let path = sysPath.join(directory, item); |
| current.add(item); |
| |
| if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) { |
| return; |
| } |
| |
| if (this.fsw.closed) { |
| stream = undefined; |
| return; |
| } |
| // Files that present in current directory snapshot |
| // but absent in previous are added to watch list and |
| // emit `add` event. |
| if (item === target || !target && !previous.has(item)) { |
| this.fsw._incrReadyCount(); |
| |
| // ensure relativeness of path is preserved in case of watcher reuse |
| path = sysPath.join(dir, sysPath.relative(dir, path)); |
| |
| this._addToNodeFs(path, initialAdd, wh, depth + 1); |
| } |
| }).on(EV_ERROR, this._boundHandleError); |
| |
| return new Promise(resolve => |
| stream.once(STR_END, () => { |
| if (this.fsw.closed) { |
| stream = undefined; |
| return; |
| } |
| const wasThrottled = throttler ? throttler.clear() : false; |
| |
| resolve(); |
| |
| // Files that absent in current directory snapshot |
| // but present in previous emit `remove` event |
| // and are removed from @watched[directory]. |
| previous.getChildren().filter((item) => { |
| return item !== directory && |
| !current.has(item) && |
| // in case of intersecting globs; |
| // a path may have been filtered out of this readdir, but |
| // shouldn't be removed because it matches a different glob |
| (!wh.hasGlob || wh.filterPath({ |
| fullPath: sysPath.resolve(directory, item) |
| })); |
| }).forEach((item) => { |
| this.fsw._remove(directory, item); |
| }); |
| |
| stream = undefined; |
| |
| // one more time for any missed in case changes came in extremely quickly |
| if (wasThrottled) this._handleRead(directory, false, wh, target, dir, depth, throttler); |
| }) |
| ); |
| } |
| |
| /** |
| * Read directory to add / remove files from `@watched` list and re-read it on change. |
| * @param {String} dir fs path |
| * @param {fs.Stats} stats |
| * @param {Boolean} initialAdd |
| * @param {Number} depth relative to user-supplied path |
| * @param {String} target child path targetted for watch |
| * @param {Object} wh Common watch helpers for this path |
| * @param {String} realpath |
| * @returns {Promise<Function>} closer for the watcher instance. |
| */ |
| async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) { |
| const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir)); |
| const tracked = parentDir.has(sysPath.basename(dir)); |
| if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) { |
| if (!wh.hasGlob || wh.globFilter(dir)) this.fsw._emit(EV_ADD_DIR, dir, stats); |
| } |
| |
| // ensure dir is tracked (harmless if redundant) |
| parentDir.add(sysPath.basename(dir)); |
| this.fsw._getWatchedDir(dir); |
| let throttler; |
| |
| |
| let closer; |
| |
| const oDepth = this.fsw.options.depth; |
| if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) { |
| if (!target) { |
| await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler); |
| if (this.fsw.closed) return; |
| } |
| |
| closer = this._watchWithNodeFs(dir, (dirPath, stats) => { |
| // if current directory is removed, do nothing |
| if (stats && stats.mtimeMs === 0) return; |
| |
| this._handleRead(dirPath, false, wh, target, dir, depth, throttler); |
| }); |
| } |
| return closer; |
| } |
| |
| /** |
| * Handle added file, directory, or glob pattern. |
| * Delegates call to _handleFile / _handleDir after checks. |
| * @param {String} path to file or ir |
| * @param {Boolean} initialAdd was the file added at watch instantiation? |
| * @param {Object} priorWh depth relative to user-supplied path |
| * @param {Number} depth Child path actually targetted for watch |
| * @param {String=} target Child path actually targeted for watch |
| * @returns {Promise} |
| */ |
| async _addToNodeFs(path, initialAdd, priorWh, depth, target) { |
| const ready = this.fsw._emitReady; |
| if (this.fsw._isIgnored(path) || this.fsw.closed) { |
| ready(); |
| return false; |
| } |
| |
| let wh = this.fsw._getWatchHelpers(path, depth); |
| if (!wh.hasGlob && priorWh) { |
| wh.hasGlob = priorWh.hasGlob; |
| wh.globFilter = priorWh.globFilter; |
| wh.filterPath = entry => priorWh.filterPath(entry); |
| wh.filterDir = entry => priorWh.filterDir(entry); |
| } |
| |
| // evaluate what is at the path we're being asked to watch |
| try { |
| const stats = await statMethods[wh.statMethod](wh.watchPath); |
| if (this.fsw.closed) return; |
| if (this.fsw._isIgnored(wh.watchPath, stats)) { |
| ready(); |
| return false; |
| } |
| |
| const follow = this.fsw.options.followSymlinks && !path.includes("*") && !path.includes("{"); |
| let closer; |
| if (stats.isDirectory()) { |
| const targetPath = follow ? await fsrealpath(path) : path; |
| if (this.fsw.closed) return; |
| closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath); |
| if (this.fsw.closed) return; |
| // preserve this symlink's target path |
| if (path !== targetPath && targetPath !== undefined) { |
| this.fsw._symlinkPaths.set(targetPath, true); |
| } |
| } else if (stats.isSymbolicLink()) { |
| const targetPath = follow ? await fsrealpath(path) : path; |
| if (this.fsw.closed) return; |
| const parent = sysPath.dirname(wh.watchPath); |
| this.fsw._getWatchedDir(parent).add(wh.watchPath); |
| this.fsw._emit(EV_ADD, wh.watchPath, stats); |
| closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath); |
| if (this.fsw.closed) return; |
| |
| // preserve this symlink's target path |
| if (targetPath !== undefined) { |
| this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath); |
| } |
| } else { |
| closer = this._handleFile(wh.watchPath, stats, initialAdd); |
| } |
| ready(); |
| |
| this.fsw._addPathCloser(path, closer); |
| return false; |
| |
| } catch (error) { |
| if (this.fsw._handleError(error)) { |
| ready(); |
| return path; |
| } |
| } |
| } |
| |
| } |
| |
| module.exports = NodeFsHandler; |