611 lines
14 KiB
JavaScript
611 lines
14 KiB
JavaScript
/*!
|
|
* Tmp
|
|
*
|
|
* Copyright (c) 2011-2017 KARASZI Istvan <github@spam.raszi.hu>
|
|
*
|
|
* MIT Licensed
|
|
*/
|
|
|
|
/*
|
|
* Module dependencies.
|
|
*/
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const crypto = require('crypto');
|
|
const osTmpDir = require('os-tmpdir');
|
|
const _c = process.binding('constants');
|
|
|
|
/*
|
|
* The working inner variables.
|
|
*/
|
|
const
|
|
/**
|
|
* The temporary directory.
|
|
* @type {string}
|
|
*/
|
|
tmpDir = osTmpDir(),
|
|
|
|
// 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),
|
|
|
|
EBADF = _c.EBADF || _c.os.errno.EBADF,
|
|
ENOENT = _c.ENOENT || _c.os.errno.ENOENT,
|
|
|
|
DIR_MODE = 448 /* 0o700 */,
|
|
FILE_MODE = 384 /* 0o600 */,
|
|
|
|
// this will hold the objects need to be removed on exit
|
|
_removeObjects = [];
|
|
|
|
var
|
|
_gracefulCleanup = false,
|
|
_uncaughtException = false;
|
|
|
|
/**
|
|
* 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) {
|
|
var
|
|
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('');
|
|
}
|
|
|
|
/**
|
|
* 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|Function)} options
|
|
* @param {Function} callback
|
|
* @returns {Array} parsed arguments
|
|
* @private
|
|
*/
|
|
function _parseArguments(options, callback) {
|
|
if (typeof options == 'function') {
|
|
return [callback || {}, options];
|
|
}
|
|
|
|
if (_isUndefined(options)) {
|
|
return [{}, callback];
|
|
}
|
|
|
|
return [options, callback];
|
|
}
|
|
|
|
/**
|
|
* Generates a new temporary name.
|
|
*
|
|
* @param {Object} opts
|
|
* @returns {string} the new random name according to opts
|
|
* @private
|
|
*/
|
|
function _generateTmpName(opts) {
|
|
if (opts.name) {
|
|
return path.join(opts.dir || tmpDir, opts.name);
|
|
}
|
|
|
|
// mkstemps like template
|
|
if (opts.template) {
|
|
return opts.template.replace(TEMPLATE_PATTERN, _randomChars(6));
|
|
}
|
|
|
|
// prefix and postfix
|
|
const name = [
|
|
opts.prefix || 'tmp-',
|
|
process.pid,
|
|
_randomChars(12),
|
|
opts.postfix || ''
|
|
].join('');
|
|
|
|
return path.join(opts.dir || tmpDir, name);
|
|
}
|
|
|
|
/**
|
|
* Gets a temporary file name.
|
|
*
|
|
* @param {(Options|tmpNameCallback)} options options or callback
|
|
* @param {?tmpNameCallback} callback the callback function
|
|
*/
|
|
function tmpName(options, callback) {
|
|
var
|
|
args = _parseArguments(options, callback),
|
|
opts = args[0],
|
|
cb = args[1],
|
|
tries = opts.name ? 1 : opts.tries || DEFAULT_TRIES;
|
|
|
|
if (isNaN(tries) || tries < 0)
|
|
return cb(new Error('Invalid tries'));
|
|
|
|
if (opts.template && !opts.template.match(TEMPLATE_PATTERN))
|
|
return cb(new Error('Invalid template provided'));
|
|
|
|
(function _getUniqueName() {
|
|
const name = _generateTmpName(opts);
|
|
|
|
// check whether the path exists then retry if needed
|
|
fs.stat(name, function (err) {
|
|
if (!err) {
|
|
if (tries-- > 0) return _getUniqueName();
|
|
|
|
return cb(new Error('Could not get a unique tmp filename, max tries reached ' + name));
|
|
}
|
|
|
|
cb(null, name);
|
|
});
|
|
}());
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
var
|
|
args = _parseArguments(options),
|
|
opts = args[0],
|
|
tries = opts.name ? 1 : opts.tries || DEFAULT_TRIES;
|
|
|
|
if (isNaN(tries) || tries < 0)
|
|
throw new Error('Invalid tries');
|
|
|
|
if (opts.template && !opts.template.match(TEMPLATE_PATTERN))
|
|
throw new Error('Invalid template provided');
|
|
|
|
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|fileCallback)} options the config options or the callback function
|
|
* @param {?fileCallback} callback
|
|
*/
|
|
function file(options, callback) {
|
|
var
|
|
args = _parseArguments(options, callback),
|
|
opts = args[0],
|
|
cb = args[1];
|
|
|
|
opts.postfix = (_isUndefined(opts.postfix)) ? '.tmp' : opts.postfix;
|
|
|
|
// gets a temporary filename
|
|
tmpName(opts, function _tmpNameCreated(err, name) {
|
|
if (err) return cb(err);
|
|
|
|
// create and open the file
|
|
fs.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err, fd) {
|
|
if (err) return cb(err);
|
|
|
|
if (opts.discardDescriptor) {
|
|
return fs.close(fd, function _discardCallback(err) {
|
|
if (err) {
|
|
// Low probability, and the file exists, so this could be
|
|
// ignored. If it isn't we certainly need to unlink the
|
|
// file, and if that fails too its error is more
|
|
// important.
|
|
try {
|
|
fs.unlinkSync(name);
|
|
} catch (e) {
|
|
if (!isENOENT(e)) {
|
|
err = e;
|
|
}
|
|
}
|
|
return cb(err);
|
|
}
|
|
cb(null, name, undefined, _prepareTmpFileRemoveCallback(name, -1, opts));
|
|
});
|
|
}
|
|
if (opts.detachDescriptor) {
|
|
return cb(null, name, fd, _prepareTmpFileRemoveCallback(name, -1, opts));
|
|
}
|
|
cb(null, name, fd, _prepareTmpFileRemoveCallback(name, fd, opts));
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
var
|
|
args = _parseArguments(options),
|
|
opts = args[0];
|
|
|
|
opts.postfix = opts.postfix || '.tmp';
|
|
|
|
const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
|
|
const name = tmpNameSync(opts);
|
|
var fd = fs.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
|
|
if (opts.discardDescriptor) {
|
|
fs.closeSync(fd);
|
|
fd = undefined;
|
|
}
|
|
|
|
return {
|
|
name: name,
|
|
fd: fd,
|
|
removeCallback: _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd, opts)
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Removes files and folders in a directory recursively.
|
|
*
|
|
* @param {string} root
|
|
* @private
|
|
*/
|
|
function _rmdirRecursiveSync(root) {
|
|
const dirs = [root];
|
|
|
|
do {
|
|
var
|
|
dir = dirs.pop(),
|
|
deferred = false,
|
|
files = fs.readdirSync(dir);
|
|
|
|
for (var i = 0, length = files.length; i < length; i++) {
|
|
var
|
|
file = path.join(dir, files[i]),
|
|
stat = fs.lstatSync(file); // lstat so we don't recurse into symlinked directories
|
|
|
|
if (stat.isDirectory()) {
|
|
if (!deferred) {
|
|
deferred = true;
|
|
dirs.push(dir);
|
|
}
|
|
dirs.push(file);
|
|
} else {
|
|
fs.unlinkSync(file);
|
|
}
|
|
}
|
|
|
|
if (!deferred) {
|
|
fs.rmdirSync(dir);
|
|
}
|
|
} while (dirs.length !== 0);
|
|
}
|
|
|
|
/**
|
|
* Creates a temporary directory.
|
|
*
|
|
* @param {(Options|dirCallback)} options the options or the callback function
|
|
* @param {?dirCallback} callback
|
|
*/
|
|
function dir(options, callback) {
|
|
var
|
|
args = _parseArguments(options, callback),
|
|
opts = args[0],
|
|
cb = args[1];
|
|
|
|
// gets a temporary filename
|
|
tmpName(opts, function _tmpNameCreated(err, name) {
|
|
if (err) return cb(err);
|
|
|
|
// create the directory
|
|
fs.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err) {
|
|
if (err) return cb(err);
|
|
|
|
cb(null, name, _prepareTmpDirRemoveCallback(name, opts));
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
var
|
|
args = _parseArguments(options),
|
|
opts = args[0];
|
|
|
|
const name = tmpNameSync(opts);
|
|
fs.mkdirSync(name, opts.mode || DIR_MODE);
|
|
|
|
return {
|
|
name: name,
|
|
removeCallback: _prepareTmpDirRemoveCallback(name, opts)
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Prepares the callback for removal of the temporary file.
|
|
*
|
|
* @param {string} name the path of the file
|
|
* @param {number} fd file descriptor
|
|
* @param {Object} opts
|
|
* @returns {fileCallback}
|
|
* @private
|
|
*/
|
|
function _prepareTmpFileRemoveCallback(name, fd, opts) {
|
|
const removeCallback = _prepareRemoveCallback(function _removeCallback(fdPath) {
|
|
try {
|
|
if (0 <= fdPath[0]) {
|
|
fs.closeSync(fdPath[0]);
|
|
}
|
|
}
|
|
catch (e) {
|
|
// under some node/windows related circumstances, a temporary file
|
|
// may have not be created as expected or the file was already closed
|
|
// by the user, in which case we will simply ignore the error
|
|
if (!isEBADF(e) && !isENOENT(e)) {
|
|
// reraise any unanticipated error
|
|
throw e;
|
|
}
|
|
}
|
|
try {
|
|
fs.unlinkSync(fdPath[1]);
|
|
}
|
|
catch (e) {
|
|
if (!isENOENT(e)) {
|
|
// reraise any unanticipated error
|
|
throw e;
|
|
}
|
|
}
|
|
}, [fd, name]);
|
|
|
|
if (!opts.keep) {
|
|
_removeObjects.unshift(removeCallback);
|
|
}
|
|
|
|
return removeCallback;
|
|
}
|
|
|
|
/**
|
|
* Prepares the callback for removal of the temporary directory.
|
|
*
|
|
* @param {string} name
|
|
* @param {Object} opts
|
|
* @returns {Function} the callback
|
|
* @private
|
|
*/
|
|
function _prepareTmpDirRemoveCallback(name, opts) {
|
|
const removeFunction = opts.unsafeCleanup ? _rmdirRecursiveSync : fs.rmdirSync.bind(fs);
|
|
const removeCallback = _prepareRemoveCallback(removeFunction, name);
|
|
|
|
if (!opts.keep) {
|
|
_removeObjects.unshift(removeCallback);
|
|
}
|
|
|
|
return removeCallback;
|
|
}
|
|
|
|
/**
|
|
* Creates a guarded function wrapping the removeFunction call.
|
|
*
|
|
* @param {Function} removeFunction
|
|
* @param {Object} arg
|
|
* @returns {Function}
|
|
* @private
|
|
*/
|
|
function _prepareRemoveCallback(removeFunction, arg) {
|
|
var called = false;
|
|
|
|
return function _cleanupCallback(next) {
|
|
if (!called) {
|
|
const index = _removeObjects.indexOf(_cleanupCallback);
|
|
if (index >= 0) {
|
|
_removeObjects.splice(index, 1);
|
|
}
|
|
|
|
called = true;
|
|
removeFunction(arg);
|
|
}
|
|
|
|
if (next) next(null);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* The garbage collector.
|
|
*
|
|
* @private
|
|
*/
|
|
function _garbageCollector() {
|
|
if (_uncaughtException && !_gracefulCleanup) {
|
|
return;
|
|
}
|
|
|
|
// the function being called removes itself from _removeObjects,
|
|
// loop until _removeObjects is empty
|
|
while (_removeObjects.length) {
|
|
try {
|
|
_removeObjects[0].call(null);
|
|
} catch (e) {
|
|
// already removed?
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper for testing against EBADF to compensate changes made to Node 7.x under Windows.
|
|
*/
|
|
function isEBADF(error) {
|
|
return isExpectedError(error, -EBADF, 'EBADF');
|
|
}
|
|
|
|
/**
|
|
* Helper for testing against ENOENT to compensate changes made to Node 7.x under Windows.
|
|
*/
|
|
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 {String|Number} any numerical value will be negated
|
|
*
|
|
* - Node >= 6.0 < 7.0:
|
|
* error.code {String}
|
|
* error.errno {Number} negated
|
|
*
|
|
* - Node >= 4.0 < 6.0: introduces SystemError
|
|
* error.code {String}
|
|
* error.errno {Number} negated
|
|
*
|
|
* - Node >= 0.10 < 4.0:
|
|
* error.code {Number} negated
|
|
* error.errno n/a
|
|
*/
|
|
function isExpectedError(error, code, errno) {
|
|
return error.code == code || error.code == errno;
|
|
}
|
|
|
|
/**
|
|
* Sets the graceful cleanup.
|
|
*
|
|
* Also removes the created files and directories when an uncaught exception occurs.
|
|
*/
|
|
function setGracefulCleanup() {
|
|
_gracefulCleanup = true;
|
|
}
|
|
|
|
const version = process.versions.node.split('.').map(function (value) {
|
|
return parseInt(value, 10);
|
|
});
|
|
|
|
if (version[0] === 0 && (version[1] < 9 || version[1] === 9 && version[2] < 5)) {
|
|
process.addListener('uncaughtException', function _uncaughtExceptionThrown(err) {
|
|
_uncaughtException = true;
|
|
_garbageCollector();
|
|
|
|
throw err;
|
|
});
|
|
}
|
|
|
|
process.addListener('exit', function _exit(code) {
|
|
if (code) _uncaughtException = true;
|
|
_garbageCollector();
|
|
});
|
|
|
|
/**
|
|
* Configuration options.
|
|
*
|
|
* @typedef {Object} Options
|
|
* @property {?number} tries the number of tries before give up the name generation
|
|
* @property {?string} template the "mkstemp" like filename template
|
|
* @property {?string} name fix name
|
|
* @property {?string} dir the tmp directory to use
|
|
* @property {?string} prefix prefix for the generated name
|
|
* @property {?string} postfix postfix for the generated name
|
|
*/
|
|
|
|
/**
|
|
* @typedef {Object} FileSyncObject
|
|
* @property {string} name the name of the file
|
|
* @property {string} fd the file descriptor
|
|
* @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
|
|
* @param {cleanupCallback} 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
|
|
*/
|
|
|
|
/**
|
|
* Removes the temporary created file or directory.
|
|
*
|
|
* @callback cleanupCallback
|
|
* @param {simpleCallback} [next] function to call after entry was removed
|
|
*/
|
|
|
|
/**
|
|
* 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
|
|
module.exports.tmpdir = tmpDir;
|
|
|
|
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;
|