watch: fix --env-file-if-exists crashing on linux if the file is missing · nodejs/node@c58fe38

<!-- YAML

added: v0.5.10

changes:

- version: REPLACEME

pr-url: https://github.com/nodejs/node/pull/61870

description: Added `throwIfNoEntry` option.

- version: v19.1.0

pr-url: https://github.com/nodejs/node/pull/45098

description: Added recursive support for Linux, AIX and IBMi.

* `encoding` {string} Specifies the character encoding to be used for the

filename passed to the listener. **Default:** `'utf8'`.

* `signal` {AbortSignal} allows closing the watcher with an AbortSignal.

* `throwIfNoEntry` {boolean} Indicates whether an exception should be thrown when the

path does not exist. **Default:** `true`.

* `ignore` {string|RegExp|Function|Array} Pattern(s) to ignore. Strings are

glob patterns (using [`minimatch`][]), RegExp patterns are tested against

the filename, and functions receive the filename and return `true` to

* recursive?: boolean;

* encoding?: string;

* signal?: AbortSignal;

* throwIfNoEntry?: boolean;

* }} [options]

* @param {(

* eventType?: string,

if (options.persistent === undefined) options.persistent = true;

if (options.recursive === undefined) options.recursive = false;

if (options.throwIfNoEntry === undefined) options.throwIfNoEntry = true;

let watcher;

const watchers = require('internal/fs/watchers');

options.persistent,

options.recursive,

options.encoding,

options.ignore);

options.ignore,

options.throwIfNoEntry);

}

if (listener) {

assert(typeof options === 'object');

const { persistent, recursive, signal, encoding, ignore } = options;

let { throwIfNoEntry } = options;

// TODO(anonrig): Add non-recursive support to non-native-watcher for IBMi & AIX support.

if (recursive != null) {

validateAbortSignal(signal, 'options.signal');

}

if (throwIfNoEntry != null) {

validateBoolean(throwIfNoEntry, 'options.throwIfNoEntry');

} else {

throwIfNoEntry = true;

}

if (encoding != null) {

// This is required since on macOS and Windows it throws ERR_INVALID_ARG_VALUE

if (typeof encoding !== 'string') {

validateIgnoreOption(ignore, 'options.ignore');

this.#ignoreMatcher = createIgnoreMatcher(ignore);

this.#options = { persistent, recursive, signal, encoding };

this.#options = { persistent, recursive, signal, encoding, throwIfNoEntry };

}

close() {

this.#watchFolder(filename);

}

} catch (error) {

if (error.code === 'ENOENT') {

if (!this.#options.throwIfNoEntry && error.code === 'ENOENT') {

error.filename = filename;

throw error;

}

} = internalBinding('fs');

const { FSEvent } = internalBinding('fs_event_wrap');

const { UV_ENOSPC } = internalBinding('uv');

const { UV_ENOSPC, UV_ENOENT } = internalBinding('uv');

const { EventEmitter } = require('events');

const {

persistent,

recursive,

encoding,

ignore) {

ignore,

throwIfNoEntry = true) {

if (this._handle === null) { // closed

return;

}

recursive,

encoding);

if (err) {

if (!throwIfNoEntry && err === UV_ENOENT) {

return;

}

const error = new UVException({

errno: err,

syscall: 'watch',

const kKillSignal = convertToValidSignal(getOptionValue('--watch-kill-signal'));

const kShouldFilterModules = getOptionValue('--watch-path').length === 0;

const kEnvFiles = [

...getOptionValue('--env-file'),

...getOptionValue('--env-file-if-exists'),

];

const kEnvFiles = getOptionValue('--env-file');

const kOptionalEnvFiles = getOptionValue('--env-file-if-exists');

const kWatchedPaths = ArrayPrototypeMap(getOptionValue('--watch-path'), (path) => resolve(path));

const kPreserveOutput = getOptionValue('--watch-preserve-output');

const kCommand = ArrayPrototypeSlice(process.argv, 1);

if (kEnvFiles.length > 0) {

ArrayPrototypeForEach(kEnvFiles, (file) => watcher.filterFile(resolve(file)));

}

if (kOptionalEnvFiles.length > 0) {

ArrayPrototypeForEach(kOptionalEnvFiles,

(file) => watcher.filterFile(resolve(file), undefined, { allowMissing: true }));

}

child.once('exit', (code) => {

exited = true;

const waitingForChanges = 'Waiting for file changes before restarting...';

}

let restarting = false;

async function restart(child) {

if (restarting) return;

restarting = true;

process.exit(exitCode ?? kNoFailure);

};

}

process.on('SIGTERM', signalHandler('SIGTERM'));

process.on('SIGINT', signalHandler('SIGINT'));

return [...this.#watchers.keys()];

}

watchPath(path, recursive = true) {

watchPath(path, recursive = true, options = kEmptyObject) {

if (this.#isPathWatched(path)) {

return;

}

const watcher = watch(path, { recursive, signal: this.#signal });

const { allowMissing = false } = options;

const watcher = watch(path, { recursive, signal: this.#signal, throwIfNoEntry: !allowMissing });

watcher.on('change', (eventType, fileName) => {

// `fileName` can be `null` if it cannot be determined. See

// https://github.com/nodejs/node/pull/49891#issuecomment-1744673430.

}

}

filterFile(file, owner) {

filterFile(file, owner, options = kEmptyObject) {

if (!file) return;

if (supportsRecursiveWatching) {

this.watchPath(dirname(file));

this.watchPath(dirname(file), true, options);

} else {

// Having multiple FSWatcher's seems to be slower

// than a single recursive FSWatcher

this.watchPath(file, false);

this.watchPath(file, false, options);

}

this.#filteredFiles.add(file);

if (owner) {

);

}

{

assert.throws(

() => fs.watch(nonexistentFile, { throwIfNoEntry: true }, common.mustNotCall()),

{

path: nonexistentFile,

filename: nonexistentFile,

code: /^(ENOENT|ENODEV)$/,

},

);

}

{

if (common.isAIX) {

assert.throws(

() => fs.watch(nonexistentFile, { throwIfNoEntry: false }, common.mustNotCall()),

{ code: 'ENODEV' },

);

} else {

const watcher = fs.watch(nonexistentFile, { throwIfNoEntry: false }, common.mustNotCall());

watcher.close();

}

}

{

if (common.isMacOS || common.isWindows) {

const file = tmpdir.resolve('file-to-watch');

}

});

it('should not crash when --env-file-if-exists points to a missing file', async () => {

const envKey = `TEST_ENV_${Date.now()}`;

const jsFile = createTmpFile(`console.log('ENV: ' + process.env.${envKey});`);

const missingEnvFile = path.join(tmpdir.path, `missing-${Date.now()}.env`);

const { done, restart } = runInBackground({

args: ['--watch-path', tmpdir.path, `--env-file-if-exists=${missingEnvFile}`, jsFile],

});

try {

const { stderr, stdout } = await restart();

assert.doesNotMatch(stderr, /ENOENT: no such file or directory, watch/);

assert.deepStrictEqual(stdout, [

'ENV: undefined',

`Completed running ${inspect(jsFile)}. Waiting for file changes before restarting...`,

]);

} finally {

await done();

}

});

it('should watch changes to a failing file', async () => {

const file = createTmpFile('throw new Error("fails");');

const { stderr, stdout } = await runWriteSucceed({