forked from lix-project/lix-website
785 lines
22 KiB
JavaScript
785 lines
22 KiB
JavaScript
|
/*!
|
||
|
* Tmp
|
||
|
*
|
||
|
* Copyright (c) 2011-2017 KARASZI Istvan <github@spam.raszi.hu>
|
||
|
*
|
||
|
* MIT Licensed
|
||
|
*/
|
||
|
|
||
|
/*
|
||
|
* Module dependencies.
|
||
|
*/
|
||
|
const fs = require('fs');
|
||
|
const os = require('os');
|
||
|
const path = require('path');
|
||
|
const crypto = require('crypto');
|
||
|
const _c = { fs: fs.constants, os: os.constants };
|
||
|
|
||
|
/*
|
||
|
* The working inner variables.
|
||
|
*/
|
||
|
const
|
||
|
// the random characters to choose from
|
||
|
RANDOM_CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
|
||
|
|
||
|
TEMPLATE_PATTERN = /XXXXXX/,
|
||
|
|
||
|
DEFAULT_TRIES = 3,
|
||
|
|
||
|
CREATE_FLAGS = (_c.O_CREAT || _c.fs.O_CREAT) | (_c.O_EXCL || _c.fs.O_EXCL) | (_c.O_RDWR || _c.fs.O_RDWR),
|
||
|
|
||
|
// constants are off on the windows platform and will not match the actual errno codes
|
||
|
IS_WIN32 = os.platform() === 'win32',
|
||
|
EBADF = _c.EBADF || _c.os.errno.EBADF,
|
||
|
ENOENT = _c.ENOENT || _c.os.errno.ENOENT,
|
||
|
|
||
|
DIR_MODE = 0o700 /* 448 */,
|
||
|
FILE_MODE = 0o600 /* 384 */,
|
||
|
|
||
|
EXIT = 'exit',
|
||
|
|
||
|
// this will hold the objects need to be removed on exit
|
||
|
_removeObjects = [],
|
||
|
|
||
|
// API change in fs.rmdirSync leads to error when passing in a second parameter, e.g. the callback
|
||
|
FN_RMDIR_SYNC = fs.rmdirSync.bind(fs);
|
||
|
|
||
|
let
|
||
|
_gracefulCleanup = false;
|
||
|
|
||
|
/**
|
||
|
* Recursively remove a directory and its contents.
|
||
|
*
|
||
|
* @param {string} dirPath path of directory to remove
|
||
|
* @param {Function} callback
|
||
|
* @private
|
||
|
*/
|
||
|
function rimraf(dirPath, callback) {
|
||
|
return fs.rm(dirPath, { recursive: true }, callback);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Recursively remove a directory and its contents, synchronously.
|
||
|
*
|
||
|
* @param {string} dirPath path of directory to remove
|
||
|
* @private
|
||
|
*/
|
||
|
function FN_RIMRAF_SYNC(dirPath) {
|
||
|
return fs.rmSync(dirPath, { recursive: true });
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Gets a temporary file name.
|
||
|
*
|
||
|
* @param {(Options|tmpNameCallback)} options options or callback
|
||
|
* @param {?tmpNameCallback} callback the callback function
|
||
|
*/
|
||
|
function tmpName(options, callback) {
|
||
|
const
|
||
|
args = _parseArguments(options, callback),
|
||
|
opts = args[0],
|
||
|
cb = args[1];
|
||
|
|
||
|
try {
|
||
|
_assertAndSanitizeOptions(opts);
|
||
|
} catch (err) {
|
||
|
return cb(err);
|
||
|
}
|
||
|
|
||
|
let tries = opts.tries;
|
||
|
(function _getUniqueName() {
|
||
|
try {
|
||
|
const name = _generateTmpName(opts);
|
||
|
|
||
|
// check whether the path exists then retry if needed
|
||
|
fs.stat(name, function (err) {
|
||
|
/* istanbul ignore else */
|
||
|
if (!err) {
|
||
|
/* istanbul ignore else */
|
||
|
if (tries-- > 0) return _getUniqueName();
|
||
|
|
||
|
return cb(new Error('Could not get a unique tmp filename, max tries reached ' + name));
|
||
|
}
|
||
|
|
||
|
cb(null, name);
|
||
|
});
|
||
|
} catch (err) {
|
||
|
cb(err);
|
||
|
}
|
||
|
}());
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Synchronous version of tmpName.
|
||
|
*
|
||
|
* @param {Object} options
|
||
|
* @returns {string} the generated random name
|
||
|
* @throws {Error} if the options are invalid or could not generate a filename
|
||
|
*/
|
||
|
function tmpNameSync(options) {
|
||
|
const
|
||
|
args = _parseArguments(options),
|
||
|
opts = args[0];
|
||
|
|
||
|
_assertAndSanitizeOptions(opts);
|
||
|
|
||
|
let tries = opts.tries;
|
||
|
do {
|
||
|
const name = _generateTmpName(opts);
|
||
|
try {
|
||
|
fs.statSync(name);
|
||
|
} catch (e) {
|
||
|
return name;
|
||
|
}
|
||
|
} while (tries-- > 0);
|
||
|
|
||
|
throw new Error('Could not get a unique tmp filename, max tries reached');
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Creates and opens a temporary file.
|
||
|
*
|
||
|
* @param {(Options|null|undefined|fileCallback)} options the config options or the callback function or null or undefined
|
||
|
* @param {?fileCallback} callback
|
||
|
*/
|
||
|
function file(options, callback) {
|
||
|
const
|
||
|
args = _parseArguments(options, callback),
|
||
|
opts = args[0],
|
||
|
cb = args[1];
|
||
|
|
||
|
// gets a temporary filename
|
||
|
tmpName(opts, function _tmpNameCreated(err, name) {
|
||
|
/* istanbul ignore else */
|
||
|
if (err) return cb(err);
|
||
|
|
||
|
// create and open the file
|
||
|
fs.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err, fd) {
|
||
|
/* istanbu ignore else */
|
||
|
if (err) return cb(err);
|
||
|
|
||
|
if (opts.discardDescriptor) {
|
||
|
return fs.close(fd, function _discardCallback(possibleErr) {
|
||
|
// the chance of getting an error on close here is rather low and might occur in the most edgiest cases only
|
||
|
return cb(possibleErr, name, undefined, _prepareTmpFileRemoveCallback(name, -1, opts, false));
|
||
|
});
|
||
|
} else {
|
||
|
// detachDescriptor passes the descriptor whereas discardDescriptor closes it, either way, we no longer care
|
||
|
// about the descriptor
|
||
|
const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
|
||
|
cb(null, name, fd, _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd, opts, false));
|
||
|
}
|
||
|
});
|
||
|
});
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Synchronous version of file.
|
||
|
*
|
||
|
* @param {Options} options
|
||
|
* @returns {FileSyncObject} object consists of name, fd and removeCallback
|
||
|
* @throws {Error} if cannot create a file
|
||
|
*/
|
||
|
function fileSync(options) {
|
||
|
const
|
||
|
args = _parseArguments(options),
|
||
|
opts = args[0];
|
||
|
|
||
|
const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
|
||
|
const name = tmpNameSync(opts);
|
||
|
var fd = fs.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
|
||
|
/* istanbul ignore else */
|
||
|
if (opts.discardDescriptor) {
|
||
|
fs.closeSync(fd);
|
||
|
fd = undefined;
|
||
|
}
|
||
|
|
||
|
return {
|
||
|
name: name,
|
||
|
fd: fd,
|
||
|
removeCallback: _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd, opts, true)
|
||
|
};
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Creates a temporary directory.
|
||
|
*
|
||
|
* @param {(Options|dirCallback)} options the options or the callback function
|
||
|
* @param {?dirCallback} callback
|
||
|
*/
|
||
|
function dir(options, callback) {
|
||
|
const
|
||
|
args = _parseArguments(options, callback),
|
||
|
opts = args[0],
|
||
|
cb = args[1];
|
||
|
|
||
|
// gets a temporary filename
|
||
|
tmpName(opts, function _tmpNameCreated(err, name) {
|
||
|
/* istanbul ignore else */
|
||
|
if (err) return cb(err);
|
||
|
|
||
|
// create the directory
|
||
|
fs.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err) {
|
||
|
/* istanbul ignore else */
|
||
|
if (err) return cb(err);
|
||
|
|
||
|
cb(null, name, _prepareTmpDirRemoveCallback(name, opts, false));
|
||
|
});
|
||
|
});
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Synchronous version of dir.
|
||
|
*
|
||
|
* @param {Options} options
|
||
|
* @returns {DirSyncObject} object consists of name and removeCallback
|
||
|
* @throws {Error} if it cannot create a directory
|
||
|
*/
|
||
|
function dirSync(options) {
|
||
|
const
|
||
|
args = _parseArguments(options),
|
||
|
opts = args[0];
|
||
|
|
||
|
const name = tmpNameSync(opts);
|
||
|
fs.mkdirSync(name, opts.mode || DIR_MODE);
|
||
|
|
||
|
return {
|
||
|
name: name,
|
||
|
removeCallback: _prepareTmpDirRemoveCallback(name, opts, true)
|
||
|
};
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Removes files asynchronously.
|
||
|
*
|
||
|
* @param {Object} fdPath
|
||
|
* @param {Function} next
|
||
|
* @private
|
||
|
*/
|
||
|
function _removeFileAsync(fdPath, next) {
|
||
|
const _handler = function (err) {
|
||
|
if (err && !_isENOENT(err)) {
|
||
|
// reraise any unanticipated error
|
||
|
return next(err);
|
||
|
}
|
||
|
next();
|
||
|
};
|
||
|
|
||
|
if (0 <= fdPath[0])
|
||
|
fs.close(fdPath[0], function () {
|
||
|
fs.unlink(fdPath[1], _handler);
|
||
|
});
|
||
|
else fs.unlink(fdPath[1], _handler);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Removes files synchronously.
|
||
|
*
|
||
|
* @param {Object} fdPath
|
||
|
* @private
|
||
|
*/
|
||
|
function _removeFileSync(fdPath) {
|
||
|
let rethrownException = null;
|
||
|
try {
|
||
|
if (0 <= fdPath[0]) fs.closeSync(fdPath[0]);
|
||
|
} catch (e) {
|
||
|
// reraise any unanticipated error
|
||
|
if (!_isEBADF(e) && !_isENOENT(e)) throw e;
|
||
|
} finally {
|
||
|
try {
|
||
|
fs.unlinkSync(fdPath[1]);
|
||
|
}
|
||
|
catch (e) {
|
||
|
// reraise any unanticipated error
|
||
|
if (!_isENOENT(e)) rethrownException = e;
|
||
|
}
|
||
|
}
|
||
|
if (rethrownException !== null) {
|
||
|
throw rethrownException;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Prepares the callback for removal of the temporary file.
|
||
|
*
|
||
|
* Returns either a sync callback or a async callback depending on whether
|
||
|
* fileSync or file was called, which is expressed by the sync parameter.
|
||
|
*
|
||
|
* @param {string} name the path of the file
|
||
|
* @param {number} fd file descriptor
|
||
|
* @param {Object} opts
|
||
|
* @param {boolean} sync
|
||
|
* @returns {fileCallback | fileCallbackSync}
|
||
|
* @private
|
||
|
*/
|
||
|
function _prepareTmpFileRemoveCallback(name, fd, opts, sync) {
|
||
|
const removeCallbackSync = _prepareRemoveCallback(_removeFileSync, [fd, name], sync);
|
||
|
const removeCallback = _prepareRemoveCallback(_removeFileAsync, [fd, name], sync, removeCallbackSync);
|
||
|
|
||
|
if (!opts.keep) _removeObjects.unshift(removeCallbackSync);
|
||
|
|
||
|
return sync ? removeCallbackSync : removeCallback;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Prepares the callback for removal of the temporary directory.
|
||
|
*
|
||
|
* Returns either a sync callback or a async callback depending on whether
|
||
|
* tmpFileSync or tmpFile was called, which is expressed by the sync parameter.
|
||
|
*
|
||
|
* @param {string} name
|
||
|
* @param {Object} opts
|
||
|
* @param {boolean} sync
|
||
|
* @returns {Function} the callback
|
||
|
* @private
|
||
|
*/
|
||
|
function _prepareTmpDirRemoveCallback(name, opts, sync) {
|
||
|
const removeFunction = opts.unsafeCleanup ? rimraf : fs.rmdir.bind(fs);
|
||
|
const removeFunctionSync = opts.unsafeCleanup ? FN_RIMRAF_SYNC : FN_RMDIR_SYNC;
|
||
|
const removeCallbackSync = _prepareRemoveCallback(removeFunctionSync, name, sync);
|
||
|
const removeCallback = _prepareRemoveCallback(removeFunction, name, sync, removeCallbackSync);
|
||
|
if (!opts.keep) _removeObjects.unshift(removeCallbackSync);
|
||
|
|
||
|
return sync ? removeCallbackSync : removeCallback;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Creates a guarded function wrapping the removeFunction call.
|
||
|
*
|
||
|
* The cleanup callback is save to be called multiple times.
|
||
|
* Subsequent invocations will be ignored.
|
||
|
*
|
||
|
* @param {Function} removeFunction
|
||
|
* @param {string} fileOrDirName
|
||
|
* @param {boolean} sync
|
||
|
* @param {cleanupCallbackSync?} cleanupCallbackSync
|
||
|
* @returns {cleanupCallback | cleanupCallbackSync}
|
||
|
* @private
|
||
|
*/
|
||
|
function _prepareRemoveCallback(removeFunction, fileOrDirName, sync, cleanupCallbackSync) {
|
||
|
let called = false;
|
||
|
|
||
|
// if sync is true, the next parameter will be ignored
|
||
|
return function _cleanupCallback(next) {
|
||
|
|
||
|
/* istanbul ignore else */
|
||
|
if (!called) {
|
||
|
// remove cleanupCallback from cache
|
||
|
const toRemove = cleanupCallbackSync || _cleanupCallback;
|
||
|
const index = _removeObjects.indexOf(toRemove);
|
||
|
/* istanbul ignore else */
|
||
|
if (index >= 0) _removeObjects.splice(index, 1);
|
||
|
|
||
|
called = true;
|
||
|
if (sync || removeFunction === FN_RMDIR_SYNC || removeFunction === FN_RIMRAF_SYNC) {
|
||
|
return removeFunction(fileOrDirName);
|
||
|
} else {
|
||
|
return removeFunction(fileOrDirName, next || function() {});
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* The garbage collector.
|
||
|
*
|
||
|
* @private
|
||
|
*/
|
||
|
function _garbageCollector() {
|
||
|
/* istanbul ignore else */
|
||
|
if (!_gracefulCleanup) return;
|
||
|
|
||
|
// the function being called removes itself from _removeObjects,
|
||
|
// loop until _removeObjects is empty
|
||
|
while (_removeObjects.length) {
|
||
|
try {
|
||
|
_removeObjects[0]();
|
||
|
} catch (e) {
|
||
|
// already removed?
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Random name generator based on crypto.
|
||
|
* Adapted from http://blog.tompawlak.org/how-to-generate-random-values-nodejs-javascript
|
||
|
*
|
||
|
* @param {number} howMany
|
||
|
* @returns {string} the generated random name
|
||
|
* @private
|
||
|
*/
|
||
|
function _randomChars(howMany) {
|
||
|
let
|
||
|
value = [],
|
||
|
rnd = null;
|
||
|
|
||
|
// make sure that we do not fail because we ran out of entropy
|
||
|
try {
|
||
|
rnd = crypto.randomBytes(howMany);
|
||
|
} catch (e) {
|
||
|
rnd = crypto.pseudoRandomBytes(howMany);
|
||
|
}
|
||
|
|
||
|
for (var i = 0; i < howMany; i++) {
|
||
|
value.push(RANDOM_CHARS[rnd[i] % RANDOM_CHARS.length]);
|
||
|
}
|
||
|
|
||
|
return value.join('');
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Helper which determines whether a string s is blank, that is undefined, or empty or null.
|
||
|
*
|
||
|
* @private
|
||
|
* @param {string} s
|
||
|
* @returns {Boolean} true whether the string s is blank, false otherwise
|
||
|
*/
|
||
|
function _isBlank(s) {
|
||
|
return s === null || _isUndefined(s) || !s.trim();
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Checks whether the `obj` parameter is defined or not.
|
||
|
*
|
||
|
* @param {Object} obj
|
||
|
* @returns {boolean} true if the object is undefined
|
||
|
* @private
|
||
|
*/
|
||
|
function _isUndefined(obj) {
|
||
|
return typeof obj === 'undefined';
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Parses the function arguments.
|
||
|
*
|
||
|
* This function helps to have optional arguments.
|
||
|
*
|
||
|
* @param {(Options|null|undefined|Function)} options
|
||
|
* @param {?Function} callback
|
||
|
* @returns {Array} parsed arguments
|
||
|
* @private
|
||
|
*/
|
||
|
function _parseArguments(options, callback) {
|
||
|
/* istanbul ignore else */
|
||
|
if (typeof options === 'function') {
|
||
|
return [{}, options];
|
||
|
}
|
||
|
|
||
|
/* istanbul ignore else */
|
||
|
if (_isUndefined(options)) {
|
||
|
return [{}, callback];
|
||
|
}
|
||
|
|
||
|
// copy options so we do not leak the changes we make internally
|
||
|
const actualOptions = {};
|
||
|
for (const key of Object.getOwnPropertyNames(options)) {
|
||
|
actualOptions[key] = options[key];
|
||
|
}
|
||
|
|
||
|
return [actualOptions, callback];
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Generates a new temporary name.
|
||
|
*
|
||
|
* @param {Object} opts
|
||
|
* @returns {string} the new random name according to opts
|
||
|
* @private
|
||
|
*/
|
||
|
function _generateTmpName(opts) {
|
||
|
|
||
|
const tmpDir = opts.tmpdir;
|
||
|
|
||
|
/* istanbul ignore else */
|
||
|
if (!_isUndefined(opts.name))
|
||
|
return path.join(tmpDir, opts.dir, opts.name);
|
||
|
|
||
|
/* istanbul ignore else */
|
||
|
if (!_isUndefined(opts.template))
|
||
|
return path.join(tmpDir, opts.dir, opts.template).replace(TEMPLATE_PATTERN, _randomChars(6));
|
||
|
|
||
|
// prefix and postfix
|
||
|
const name = [
|
||
|
opts.prefix ? opts.prefix : 'tmp',
|
||
|
'-',
|
||
|
process.pid,
|
||
|
'-',
|
||
|
_randomChars(12),
|
||
|
opts.postfix ? '-' + opts.postfix : ''
|
||
|
].join('');
|
||
|
|
||
|
return path.join(tmpDir, opts.dir, name);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Asserts whether the specified options are valid, also sanitizes options and provides sane defaults for missing
|
||
|
* options.
|
||
|
*
|
||
|
* @param {Options} options
|
||
|
* @private
|
||
|
*/
|
||
|
function _assertAndSanitizeOptions(options) {
|
||
|
|
||
|
options.tmpdir = _getTmpDir(options);
|
||
|
|
||
|
const tmpDir = options.tmpdir;
|
||
|
|
||
|
/* istanbul ignore else */
|
||
|
if (!_isUndefined(options.name))
|
||
|
_assertIsRelative(options.name, 'name', tmpDir);
|
||
|
/* istanbul ignore else */
|
||
|
if (!_isUndefined(options.dir))
|
||
|
_assertIsRelative(options.dir, 'dir', tmpDir);
|
||
|
/* istanbul ignore else */
|
||
|
if (!_isUndefined(options.template)) {
|
||
|
_assertIsRelative(options.template, 'template', tmpDir);
|
||
|
if (!options.template.match(TEMPLATE_PATTERN))
|
||
|
throw new Error(`Invalid template, found "${options.template}".`);
|
||
|
}
|
||
|
/* istanbul ignore else */
|
||
|
if (!_isUndefined(options.tries) && isNaN(options.tries) || options.tries < 0)
|
||
|
throw new Error(`Invalid tries, found "${options.tries}".`);
|
||
|
|
||
|
// if a name was specified we will try once
|
||
|
options.tries = _isUndefined(options.name) ? options.tries || DEFAULT_TRIES : 1;
|
||
|
options.keep = !!options.keep;
|
||
|
options.detachDescriptor = !!options.detachDescriptor;
|
||
|
options.discardDescriptor = !!options.discardDescriptor;
|
||
|
options.unsafeCleanup = !!options.unsafeCleanup;
|
||
|
|
||
|
// sanitize dir, also keep (multiple) blanks if the user, purportedly sane, requests us to
|
||
|
options.dir = _isUndefined(options.dir) ? '' : path.relative(tmpDir, _resolvePath(options.dir, tmpDir));
|
||
|
options.template = _isUndefined(options.template) ? undefined : path.relative(tmpDir, _resolvePath(options.template, tmpDir));
|
||
|
// sanitize further if template is relative to options.dir
|
||
|
options.template = _isBlank(options.template) ? undefined : path.relative(options.dir, options.template);
|
||
|
|
||
|
// for completeness' sake only, also keep (multiple) blanks if the user, purportedly sane, requests us to
|
||
|
options.name = _isUndefined(options.name) ? undefined : options.name;
|
||
|
options.prefix = _isUndefined(options.prefix) ? '' : options.prefix;
|
||
|
options.postfix = _isUndefined(options.postfix) ? '' : options.postfix;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Resolve the specified path name in respect to tmpDir.
|
||
|
*
|
||
|
* The specified name might include relative path components, e.g. ../
|
||
|
* so we need to resolve in order to be sure that is is located inside tmpDir
|
||
|
*
|
||
|
* @param name
|
||
|
* @param tmpDir
|
||
|
* @returns {string}
|
||
|
* @private
|
||
|
*/
|
||
|
function _resolvePath(name, tmpDir) {
|
||
|
if (name.startsWith(tmpDir)) {
|
||
|
return path.resolve(name);
|
||
|
} else {
|
||
|
return path.resolve(path.join(tmpDir, name));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Asserts whether specified name is relative to the specified tmpDir.
|
||
|
*
|
||
|
* @param {string} name
|
||
|
* @param {string} option
|
||
|
* @param {string} tmpDir
|
||
|
* @throws {Error}
|
||
|
* @private
|
||
|
*/
|
||
|
function _assertIsRelative(name, option, tmpDir) {
|
||
|
if (option === 'name') {
|
||
|
// assert that name is not absolute and does not contain a path
|
||
|
if (path.isAbsolute(name))
|
||
|
throw new Error(`${option} option must not contain an absolute path, found "${name}".`);
|
||
|
// must not fail on valid .<name> or ..<name> or similar such constructs
|
||
|
let basename = path.basename(name);
|
||
|
if (basename === '..' || basename === '.' || basename !== name)
|
||
|
throw new Error(`${option} option must not contain a path, found "${name}".`);
|
||
|
}
|
||
|
else { // if (option === 'dir' || option === 'template') {
|
||
|
// assert that dir or template are relative to tmpDir
|
||
|
if (path.isAbsolute(name) && !name.startsWith(tmpDir)) {
|
||
|
throw new Error(`${option} option must be relative to "${tmpDir}", found "${name}".`);
|
||
|
}
|
||
|
let resolvedPath = _resolvePath(name, tmpDir);
|
||
|
if (!resolvedPath.startsWith(tmpDir))
|
||
|
throw new Error(`${option} option must be relative to "${tmpDir}", found "${resolvedPath}".`);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Helper for testing against EBADF to compensate changes made to Node 7.x under Windows.
|
||
|
*
|
||
|
* @private
|
||
|
*/
|
||
|
function _isEBADF(error) {
|
||
|
return _isExpectedError(error, -EBADF, 'EBADF');
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Helper for testing against ENOENT to compensate changes made to Node 7.x under Windows.
|
||
|
*
|
||
|
* @private
|
||
|
*/
|
||
|
function _isENOENT(error) {
|
||
|
return _isExpectedError(error, -ENOENT, 'ENOENT');
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Helper to determine whether the expected error code matches the actual code and errno,
|
||
|
* which will differ between the supported node versions.
|
||
|
*
|
||
|
* - Node >= 7.0:
|
||
|
* error.code {string}
|
||
|
* error.errno {number} any numerical value will be negated
|
||
|
*
|
||
|
* CAVEAT
|
||
|
*
|
||
|
* On windows, the errno for EBADF is -4083 but os.constants.errno.EBADF is different and we must assume that ENOENT
|
||
|
* is no different here.
|
||
|
*
|
||
|
* @param {SystemError} error
|
||
|
* @param {number} errno
|
||
|
* @param {string} code
|
||
|
* @private
|
||
|
*/
|
||
|
function _isExpectedError(error, errno, code) {
|
||
|
return IS_WIN32 ? error.code === code : error.code === code && error.errno === errno;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Sets the graceful cleanup.
|
||
|
*
|
||
|
* If graceful cleanup is set, tmp will remove all controlled temporary objects on process exit, otherwise the
|
||
|
* temporary objects will remain in place, waiting to be cleaned up on system restart or otherwise scheduled temporary
|
||
|
* object removals.
|
||
|
*/
|
||
|
function setGracefulCleanup() {
|
||
|
_gracefulCleanup = true;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Returns the currently configured tmp dir from os.tmpdir().
|
||
|
*
|
||
|
* @private
|
||
|
* @param {?Options} options
|
||
|
* @returns {string} the currently configured tmp dir
|
||
|
*/
|
||
|
function _getTmpDir(options) {
|
||
|
return path.resolve(options && options.tmpdir || os.tmpdir());
|
||
|
}
|
||
|
|
||
|
// Install process exit listener
|
||
|
process.addListener(EXIT, _garbageCollector);
|
||
|
|
||
|
/**
|
||
|
* Configuration options.
|
||
|
*
|
||
|
* @typedef {Object} Options
|
||
|
* @property {?boolean} keep the temporary object (file or dir) will not be garbage collected
|
||
|
* @property {?number} tries the number of tries before give up the name generation
|
||
|
* @property (?int) mode the access mode, defaults are 0o700 for directories and 0o600 for files
|
||
|
* @property {?string} template the "mkstemp" like filename template
|
||
|
* @property {?string} name fixed name relative to tmpdir or the specified dir option
|
||
|
* @property {?string} dir tmp directory relative to the root tmp directory in use
|
||
|
* @property {?string} prefix prefix for the generated name
|
||
|
* @property {?string} postfix postfix for the generated name
|
||
|
* @property {?string} tmpdir the root tmp directory which overrides the os tmpdir
|
||
|
* @property {?boolean} unsafeCleanup recursively removes the created temporary directory, even when it's not empty
|
||
|
* @property {?boolean} detachDescriptor detaches the file descriptor, caller is responsible for closing the file, tmp will no longer try closing the file during garbage collection
|
||
|
* @property {?boolean} discardDescriptor discards the file descriptor (closes file, fd is -1), tmp will no longer try closing the file during garbage collection
|
||
|
*/
|
||
|
|
||
|
/**
|
||
|
* @typedef {Object} FileSyncObject
|
||
|
* @property {string} name the name of the file
|
||
|
* @property {string} fd the file descriptor or -1 if the fd has been discarded
|
||
|
* @property {fileCallback} removeCallback the callback function to remove the file
|
||
|
*/
|
||
|
|
||
|
/**
|
||
|
* @typedef {Object} DirSyncObject
|
||
|
* @property {string} name the name of the directory
|
||
|
* @property {fileCallback} removeCallback the callback function to remove the directory
|
||
|
*/
|
||
|
|
||
|
/**
|
||
|
* @callback tmpNameCallback
|
||
|
* @param {?Error} err the error object if anything goes wrong
|
||
|
* @param {string} name the temporary file name
|
||
|
*/
|
||
|
|
||
|
/**
|
||
|
* @callback fileCallback
|
||
|
* @param {?Error} err the error object if anything goes wrong
|
||
|
* @param {string} name the temporary file name
|
||
|
* @param {number} fd the file descriptor or -1 if the fd had been discarded
|
||
|
* @param {cleanupCallback} fn the cleanup callback function
|
||
|
*/
|
||
|
|
||
|
/**
|
||
|
* @callback fileCallbackSync
|
||
|
* @param {?Error} err the error object if anything goes wrong
|
||
|
* @param {string} name the temporary file name
|
||
|
* @param {number} fd the file descriptor or -1 if the fd had been discarded
|
||
|
* @param {cleanupCallbackSync} fn the cleanup callback function
|
||
|
*/
|
||
|
|
||
|
/**
|
||
|
* @callback dirCallback
|
||
|
* @param {?Error} err the error object if anything goes wrong
|
||
|
* @param {string} name the temporary file name
|
||
|
* @param {cleanupCallback} fn the cleanup callback function
|
||
|
*/
|
||
|
|
||
|
/**
|
||
|
* @callback dirCallbackSync
|
||
|
* @param {?Error} err the error object if anything goes wrong
|
||
|
* @param {string} name the temporary file name
|
||
|
* @param {cleanupCallbackSync} fn the cleanup callback function
|
||
|
*/
|
||
|
|
||
|
/**
|
||
|
* Removes the temporary created file or directory.
|
||
|
*
|
||
|
* @callback cleanupCallback
|
||
|
* @param {simpleCallback} [next] function to call whenever the tmp object needs to be removed
|
||
|
*/
|
||
|
|
||
|
/**
|
||
|
* Removes the temporary created file or directory.
|
||
|
*
|
||
|
* @callback cleanupCallbackSync
|
||
|
*/
|
||
|
|
||
|
/**
|
||
|
* Callback function for function composition.
|
||
|
* @see {@link https://github.com/raszi/node-tmp/issues/57|raszi/node-tmp#57}
|
||
|
*
|
||
|
* @callback simpleCallback
|
||
|
*/
|
||
|
|
||
|
// exporting all the needed methods
|
||
|
|
||
|
// evaluate _getTmpDir() lazily, mainly for simplifying testing but it also will
|
||
|
// allow users to reconfigure the temporary directory
|
||
|
Object.defineProperty(module.exports, 'tmpdir', {
|
||
|
enumerable: true,
|
||
|
configurable: false,
|
||
|
get: function () {
|
||
|
return _getTmpDir();
|
||
|
}
|
||
|
});
|
||
|
|
||
|
module.exports.dir = dir;
|
||
|
module.exports.dirSync = dirSync;
|
||
|
|
||
|
module.exports.file = file;
|
||
|
module.exports.fileSync = fileSync;
|
||
|
|
||
|
module.exports.tmpName = tmpName;
|
||
|
module.exports.tmpNameSync = tmpNameSync;
|
||
|
|
||
|
module.exports.setGracefulCleanup = setGracefulCleanup;
|