Initial commit
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
dinlo
+20
@@ -0,0 +1,20 @@
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2010-2014 Bruce Williams
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
this software and associated documentation files (the "Software"), to deal in
|
||||
the Software without restriction, including without limitation the rights to
|
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
+271
@@ -0,0 +1,271 @@
|
||||
|
||||
=========
|
||||
|
||||
Temporary files, directories, and streams for Node.js.
|
||||
|
||||
Handles generating a unique file/directory name under the appropriate
|
||||
system temporary directory, changing the file to an appropriate mode,
|
||||
and supports automatic removal (if asked)
|
||||
|
||||
`temp` has a similar API to the `fs` module.
|
||||
|
||||
Node.js Compatibility
|
||||
---------------------
|
||||
|
||||
Supports v6.0.0+.
|
||||
|
||||
[](https://travis-ci.org/bruce/node-temp)
|
||||
|
||||
Please let me know if you have problems running it on a later version of Node.js or
|
||||
have platform-specific problems.
|
||||
|
||||
Installation
|
||||
------------
|
||||
|
||||
Install it using [npm](http://github.com/isaacs/npm):
|
||||
|
||||
$ npm install temp
|
||||
|
||||
Or get it directly from:
|
||||
http://github.com/bruce/node-temp
|
||||
|
||||
Synopsis
|
||||
--------
|
||||
|
||||
You can create temporary files with `open` and `openSync`, temporary
|
||||
directories with `mkdir` and `mkdirSync`, or you can get a unique name
|
||||
in the system temporary directory with `path`.
|
||||
|
||||
Working copies of the following examples can be found under the
|
||||
`examples` directory.
|
||||
|
||||
### Temporary Files
|
||||
|
||||
To create a temporary file use `open` or `openSync`, passing
|
||||
them an optional prefix, suffix, or both (see below for details on
|
||||
affixes). The object passed to the callback (or returned) has
|
||||
`path` and `fd` keys:
|
||||
|
||||
```javascript
|
||||
{ path: "/path/to/file",
|
||||
, fd: theFileDescriptor
|
||||
}
|
||||
```
|
||||
|
||||
In this example we write to a temporary file and call out to `grep` and
|
||||
`wc -l` to determine the number of time `foo` occurs in the text. The
|
||||
temporary file is chmod'd `0600` and cleaned up automatically when the
|
||||
process at exit (because `temp.track()` is called):
|
||||
|
||||
```javascript
|
||||
var temp = require('temp'),
|
||||
fs = require('fs'),
|
||||
util = require('util'),
|
||||
exec = require('child_process').exec;
|
||||
|
||||
// Automatically track and cleanup files at exit
|
||||
temp.track();
|
||||
|
||||
// Fake data
|
||||
var myData = "foo\nbar\nfoo\nbaz";
|
||||
|
||||
// Process the data (note: error handling omitted)
|
||||
temp.open('myprefix', function(err, info) {
|
||||
if (!err) {
|
||||
fs.write(info.fd, myData, (err) => {
|
||||
console.log(err);
|
||||
});
|
||||
fs.close(info.fd, function(err) {
|
||||
exec("grep foo '" + info.path + "' | wc -l", function(err, stdout) {
|
||||
util.puts(stdout.trim());
|
||||
});
|
||||
});
|
||||
}
|
||||
});
|
||||
```
|
||||
|
||||
### Want Cleanup? Make sure you ask for it.
|
||||
|
||||
As noted in the example above, if you want temp to track the files and
|
||||
directories it creates and handle removing those files and directories
|
||||
on exit, you must call `track()`. The `track()` function is chainable,
|
||||
and it's recommended that you call it when requiring the module.
|
||||
|
||||
```javascript
|
||||
var temp = require("temp").track();
|
||||
```
|
||||
|
||||
Why is this necessary? In pre-0.6 versions of temp, tracking was
|
||||
automatic. While this works great for scripts and
|
||||
[Grunt tasks](http://gruntjs.com/), it's not so great for long-running
|
||||
server processes. Since that's arguably what Node.js is _for_, you
|
||||
have to opt-in to tracking.
|
||||
|
||||
But it's easy.
|
||||
|
||||
#### Cleanup anytime
|
||||
|
||||
When tracking, you can run `cleanup()` and `cleanupSync()` anytime
|
||||
(`cleanupSync()` will be run for you on process exit). An object will
|
||||
be returned (or passed to the callback) with cleanup counts and
|
||||
the file/directory tracking lists will be reset.
|
||||
|
||||
```javascript
|
||||
> temp.cleanupSync();
|
||||
{ files: 1,
|
||||
dirs: 0 }
|
||||
```
|
||||
|
||||
```javascript
|
||||
> temp.cleanup(function(err, stats) {
|
||||
console.log(stats);
|
||||
});
|
||||
{ files: 1,
|
||||
dirs: 0 }
|
||||
```
|
||||
|
||||
Note: If you're not tracking, an error ("not tracking") will be passed
|
||||
to the callback.
|
||||
|
||||
### Temporary Directories
|
||||
|
||||
To create a temporary directory, use `mkdir` or `mkdirSync`, passing
|
||||
it an optional prefix, suffix, or both (see below for details on affixes).
|
||||
|
||||
In this example we create a temporary directory, write to a file
|
||||
within it, call out to an external program to create a PDF, and read
|
||||
the result. While the external process creates a lot of additional
|
||||
files, the temporary directory is removed automatically at exit (because
|
||||
`temp.track()` is called):
|
||||
|
||||
```javascript
|
||||
var temp = require('temp'),
|
||||
fs = require('fs'),
|
||||
util = require('util'),
|
||||
path = require('path'),
|
||||
exec = require('child_process').exec;
|
||||
|
||||
// Automatically track and cleanup files at exit
|
||||
temp.track();
|
||||
|
||||
// For use with ConTeXt, http://wiki.contextgarden.net
|
||||
var myData = "\\starttext\nHello World\n\\stoptext";
|
||||
|
||||
temp.mkdir('pdfcreator', function(err, dirPath) {
|
||||
var inputPath = path.join(dirPath, 'input.tex')
|
||||
fs.writeFile(inputPath, myData, function(err) {
|
||||
if (err) throw err;
|
||||
process.chdir(dirPath);
|
||||
exec("texexec '" + inputPath + "'", function(err) {
|
||||
if (err) throw err;
|
||||
fs.readFile(path.join(dirPath, 'input.pdf'), function(err, data) {
|
||||
if (err) throw err;
|
||||
sys.print(data);
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
```
|
||||
|
||||
### Temporary Streams
|
||||
|
||||
To create a temporary WriteStream, use 'createWriteStream', which sits
|
||||
on top of `fs.createWriteStream`. The return value is a
|
||||
`fs.WriteStream` with a `path` property containing the temporary file
|
||||
path for the stream. The `path` is registered for removal when
|
||||
`temp.cleanup` is called (because `temp.track()` is called).
|
||||
|
||||
```javascript
|
||||
var temp = require('temp');
|
||||
|
||||
// Automatically track and cleanup files at exit
|
||||
temp.track();
|
||||
|
||||
var stream = temp.createWriteStream();
|
||||
// stream.path contains the temporary file path for the stream
|
||||
stream.write("Some data");
|
||||
// Maybe do some other things
|
||||
stream.end();
|
||||
```
|
||||
|
||||
### Affixes
|
||||
|
||||
You can provide custom prefixes and suffixes when creating temporary
|
||||
files and directories. If you provide a string, it is used as the prefix
|
||||
for the temporary name. If you provide an object with `prefix`,
|
||||
`suffix` and `dir` keys, they are used for the temporary name.
|
||||
|
||||
Here are some examples:
|
||||
|
||||
* `"aprefix"`: A simple prefix, prepended to the filename; this is
|
||||
shorthand for:
|
||||
* `{prefix: "aprefix"}`: A simple prefix, prepended to the filename
|
||||
* `{suffix: ".asuffix"}`: A suffix, appended to the filename
|
||||
(especially useful when the file needs to be named with specific
|
||||
extension for use with an external program).
|
||||
* `{prefix: "myprefix", suffix: "mysuffix"}`: Customize both affixes
|
||||
* `{dir: path.join(os.tmpdir(), "myapp")}`: default prefix and suffix
|
||||
within a new temporary directory.
|
||||
* `null`: Use the defaults for files and directories (prefixes `"f-"`
|
||||
and `"d-"`, respectively, no suffixes).
|
||||
|
||||
In this simple example we read a `pdf`, write it to a temporary file with
|
||||
a `.pdf` extension, and close it.
|
||||
|
||||
```javascript
|
||||
var fs = require('fs'),
|
||||
temp = require('temp');
|
||||
|
||||
fs.readFile('/path/to/source.pdf', function(err, data) {
|
||||
temp.open({suffix: '.pdf'}, function(err, info) {
|
||||
if (err) throw err;
|
||||
fs.write(info.fd, data, (err) => {
|
||||
console.log(err)
|
||||
});
|
||||
fs.close(info.fd, function(err) {
|
||||
if (err) throw err;
|
||||
// Do something with the file
|
||||
});
|
||||
});
|
||||
});
|
||||
```
|
||||
|
||||
### Just a path, please
|
||||
|
||||
If you just want a unique name in your temporary directory, use
|
||||
`path`:
|
||||
|
||||
```javascript
|
||||
var fs = require('fs');
|
||||
var tempName = temp.path({suffix: '.pdf'});
|
||||
// Do something with tempName
|
||||
```
|
||||
|
||||
Note: The file isn't created for you, and the mode is not changed -- and it
|
||||
will not be removed automatically at exit. If you use `path`, it's
|
||||
all up to you.
|
||||
|
||||
Testing
|
||||
-------
|
||||
|
||||
```sh
|
||||
$ npm test
|
||||
```
|
||||
|
||||
Contributing
|
||||
------------
|
||||
|
||||
You can find the repository at:
|
||||
http://github.com/bruce/node-temp
|
||||
|
||||
Issues/Feature Requests can be submitted at:
|
||||
http://github.com/bruce/node-temp/issues
|
||||
|
||||
I'd really like to hear your feedback, and I'd love to receive your
|
||||
pull-requests!
|
||||
|
||||
Copyright
|
||||
---------
|
||||
|
||||
Copyright (c) 2010-2014 Bruce Williams. This software is licensed
|
||||
under the MIT License, see LICENSE for details.
|
||||
+326
@@ -0,0 +1,326 @@
|
||||
let fs = require('fs');
|
||||
let path = require('path');
|
||||
let cnst = require('constants');
|
||||
|
||||
let os = require('os');
|
||||
let rimraf = require('rimraf');
|
||||
let mkdirp = require('mkdirp');
|
||||
let osTmpdir = require('os').tmpdir();
|
||||
|
||||
const rimrafSync = rimraf.sync;
|
||||
|
||||
//== helpers
|
||||
//
|
||||
let dir = path.resolve(os.tmpdir());
|
||||
|
||||
let RDWR_EXCL = cnst.O_CREAT | cnst.O_TRUNC | cnst.O_RDWR | cnst.O_EXCL;
|
||||
|
||||
let promisify = function(callback) {
|
||||
if (typeof callback === 'function') {
|
||||
return [undefined, callback];
|
||||
}
|
||||
|
||||
var promiseCallback;
|
||||
var promise = new Promise(function(resolve, reject) {
|
||||
promiseCallback = function() {
|
||||
var args = Array.from(arguments);
|
||||
var err = args.shift();
|
||||
|
||||
process.nextTick(function() {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else if (args.length === 1) {
|
||||
resolve(args[0]);
|
||||
} else {
|
||||
resolve(args);
|
||||
}
|
||||
});
|
||||
};
|
||||
});
|
||||
|
||||
return [promise, promiseCallback];
|
||||
};
|
||||
|
||||
var generateName = function(rawAffixes, defaultPrefix) {
|
||||
var affixes = parseAffixes(rawAffixes, defaultPrefix);
|
||||
var now = new Date();
|
||||
var name = [affixes.prefix,
|
||||
now.getFullYear(), now.getMonth(), now.getDate(),
|
||||
'-',
|
||||
process.pid,
|
||||
'-',
|
||||
(Math.random() * 0x100000000 + 1).toString(36),
|
||||
affixes.suffix].join('');
|
||||
return path.join(affixes.dir || dir, name);
|
||||
};
|
||||
|
||||
var parseAffixes = function(rawAffixes, defaultPrefix) {
|
||||
var affixes = {prefix: null, suffix: null};
|
||||
if(rawAffixes) {
|
||||
switch (typeof(rawAffixes)) {
|
||||
case 'string':
|
||||
affixes.prefix = rawAffixes;
|
||||
break;
|
||||
case 'object':
|
||||
affixes = rawAffixes;
|
||||
break;
|
||||
default:
|
||||
throw new Error("Unknown affix declaration: " + affixes);
|
||||
}
|
||||
} else {
|
||||
affixes.prefix = defaultPrefix;
|
||||
}
|
||||
return affixes;
|
||||
};
|
||||
|
||||
/* -------------------------------------------------------------------------
|
||||
* Don't forget to call track() if you want file tracking and exit handlers!
|
||||
* -------------------------------------------------------------------------
|
||||
* When any temp file or directory is created, it is added to filesToDelete
|
||||
* or dirsToDelete. The first time any temp file is created, a listener is
|
||||
* added to remove all temp files and directories at exit.
|
||||
*/
|
||||
var tracking = false;
|
||||
var track = function(value) {
|
||||
tracking = (value !== false);
|
||||
return module.exports; // chainable
|
||||
};
|
||||
var exitListenerAttached = false;
|
||||
var filesToDelete = [];
|
||||
var dirsToDelete = [];
|
||||
|
||||
function deleteFileOnExit(filePath) {
|
||||
if (!tracking) return false;
|
||||
attachExitListener();
|
||||
filesToDelete.push(filePath);
|
||||
}
|
||||
|
||||
function deleteDirOnExit(dirPath) {
|
||||
if (!tracking) return false;
|
||||
attachExitListener();
|
||||
dirsToDelete.push(dirPath);
|
||||
}
|
||||
|
||||
function attachExitListener() {
|
||||
if (!tracking) return false;
|
||||
if (!exitListenerAttached) {
|
||||
process.addListener('exit', function() {
|
||||
try {
|
||||
cleanupSync();
|
||||
} catch(err) {
|
||||
console.warn("Fail to clean temporary files on exit : ", err);
|
||||
throw err;
|
||||
}
|
||||
});
|
||||
exitListenerAttached = true;
|
||||
}
|
||||
}
|
||||
|
||||
function cleanupFilesSync() {
|
||||
if (!tracking) {
|
||||
return false;
|
||||
}
|
||||
var count = 0;
|
||||
var toDelete;
|
||||
while ((toDelete = filesToDelete.shift()) !== undefined) {
|
||||
rimrafSync(toDelete, { maxBusyTries: 6 });
|
||||
count++;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
function cleanupFiles(callback) {
|
||||
var p = promisify(callback);
|
||||
var promise = p[0];
|
||||
callback = p[1];
|
||||
|
||||
if (!tracking) {
|
||||
callback(new Error("not tracking"));
|
||||
return promise;
|
||||
}
|
||||
var count = 0;
|
||||
var left = filesToDelete.length;
|
||||
if (!left) {
|
||||
callback(null, count);
|
||||
return promise;
|
||||
}
|
||||
var toDelete;
|
||||
var rimrafCallback = function(err) {
|
||||
if (!left) {
|
||||
// Prevent processing if aborted
|
||||
return;
|
||||
}
|
||||
if (err) {
|
||||
// This shouldn't happen; pass error to callback and abort
|
||||
// processing
|
||||
callback(err);
|
||||
left = 0;
|
||||
return;
|
||||
} else {
|
||||
count++;
|
||||
}
|
||||
left--;
|
||||
if (!left) {
|
||||
callback(null, count);
|
||||
}
|
||||
};
|
||||
while ((toDelete = filesToDelete.shift()) !== undefined) {
|
||||
rimraf(toDelete, { maxBusyTries: 6 }, rimrafCallback);
|
||||
}
|
||||
return promise;
|
||||
}
|
||||
|
||||
function cleanupDirsSync() {
|
||||
if (!tracking) {
|
||||
return false;
|
||||
}
|
||||
var count = 0;
|
||||
var toDelete;
|
||||
while ((toDelete = dirsToDelete.shift()) !== undefined) {
|
||||
rimrafSync(toDelete, { maxBusyTries: 6 });
|
||||
count++;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
function cleanupDirs(callback) {
|
||||
var p = promisify(callback);
|
||||
var promise = p[0];
|
||||
callback = p[1];
|
||||
|
||||
if (!tracking) {
|
||||
callback(new Error("not tracking"));
|
||||
return promise;
|
||||
}
|
||||
var count = 0;
|
||||
var left = dirsToDelete.length;
|
||||
if (!left) {
|
||||
callback(null, count);
|
||||
return promise;
|
||||
}
|
||||
var toDelete;
|
||||
var rimrafCallback = function (err) {
|
||||
if (!left) {
|
||||
// Prevent processing if aborted
|
||||
return;
|
||||
}
|
||||
if (err) {
|
||||
// rimraf handles most "normal" errors; pass the error to the
|
||||
// callback and abort processing
|
||||
callback(err, count);
|
||||
left = 0;
|
||||
return;
|
||||
} else {
|
||||
count++;
|
||||
}
|
||||
left--;
|
||||
if (!left) {
|
||||
callback(null, count);
|
||||
}
|
||||
};
|
||||
while ((toDelete = dirsToDelete.shift()) !== undefined) {
|
||||
rimraf(toDelete, { maxBusyTries: 6 }, rimrafCallback);
|
||||
}
|
||||
return promise;
|
||||
}
|
||||
|
||||
function cleanupSync() {
|
||||
if (!tracking) {
|
||||
return false;
|
||||
}
|
||||
var fileCount = cleanupFilesSync();
|
||||
var dirCount = cleanupDirsSync();
|
||||
return {files: fileCount, dirs: dirCount};
|
||||
}
|
||||
|
||||
function cleanup(callback) {
|
||||
var p = promisify(callback);
|
||||
var promise = p[0];
|
||||
callback = p[1];
|
||||
|
||||
if (!tracking) {
|
||||
callback(new Error("not tracking"));
|
||||
return promise;
|
||||
}
|
||||
cleanupFiles(function(fileErr, fileCount) {
|
||||
if (fileErr) {
|
||||
callback(fileErr, {files: fileCount});
|
||||
} else {
|
||||
cleanupDirs(function(dirErr, dirCount) {
|
||||
callback(dirErr, {files: fileCount, dirs: dirCount});
|
||||
});
|
||||
}
|
||||
});
|
||||
return promise;
|
||||
}
|
||||
|
||||
//== directories
|
||||
//
|
||||
const mkdir = (affixes, callback) => {
|
||||
const p = promisify(callback);
|
||||
const promise = p[0];
|
||||
callback = p[1];
|
||||
|
||||
let dirPath = generateName(affixes, 'd-');
|
||||
mkdirp(dirPath, 0o700, (err) => {
|
||||
if (!err) {
|
||||
deleteDirOnExit(dirPath);
|
||||
}
|
||||
callback(err, dirPath);
|
||||
});
|
||||
return promise;
|
||||
}
|
||||
|
||||
const mkdirSync = (affixes) => {
|
||||
let dirPath = generateName(affixes, 'd-');
|
||||
mkdirp.sync(dirPath, 0o700);
|
||||
deleteDirOnExit(dirPath);
|
||||
return dirPath;
|
||||
}
|
||||
|
||||
//== files
|
||||
//
|
||||
const open = (affixes, callback) => {
|
||||
const p = promisify(callback);
|
||||
const promise = p[0];
|
||||
callback = p[1];
|
||||
|
||||
const path = generateName(affixes, 'f-');
|
||||
fs.open(path, RDWR_EXCL, 0o600, (err, fd) => {
|
||||
if (!err) {
|
||||
deleteFileOnExit(path);
|
||||
}
|
||||
callback(err, { path, fd });
|
||||
});
|
||||
return promise;
|
||||
}
|
||||
|
||||
const openSync = (affixes) => {
|
||||
const path = generateName(affixes, 'f-');
|
||||
let fd = fs.openSync(path, RDWR_EXCL, 0o600);
|
||||
deleteFileOnExit(path);
|
||||
return { path, fd };
|
||||
}
|
||||
|
||||
const createWriteStream = (affixes) => {
|
||||
const path = generateName(affixes, 's-');
|
||||
let stream = fs.createWriteStream(path, { flags: RDWR_EXCL, mode: 0o600 });
|
||||
deleteFileOnExit(path);
|
||||
return stream;
|
||||
}
|
||||
|
||||
//== settings
|
||||
//
|
||||
exports.dir = dir;
|
||||
exports.track = track;
|
||||
|
||||
//== functions
|
||||
//
|
||||
exports.mkdir = mkdir;
|
||||
exports.mkdirSync = mkdirSync;
|
||||
exports.open = open;
|
||||
exports.openSync = openSync;
|
||||
exports.path = generateName;
|
||||
exports.cleanup = cleanup;
|
||||
exports.cleanupSync = cleanupSync;
|
||||
exports.createWriteStream = createWriteStream;
|
||||
+49
@@ -0,0 +1,49 @@
|
||||
{
|
||||
"name": "temp",
|
||||
"description": "Temporary files and directories",
|
||||
"tags": [
|
||||
"temporary",
|
||||
"temp",
|
||||
"tempfile",
|
||||
"tempdir",
|
||||
"tmpfile",
|
||||
"tmpdir",
|
||||
"security"
|
||||
],
|
||||
"version": "0.9.4",
|
||||
"author": "Bruce Williams <brwcodes@gmail.com>",
|
||||
"license": "MIT",
|
||||
"directories": {
|
||||
"lib": "lib"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=6.0.0"
|
||||
},
|
||||
"main": "./lib/temp",
|
||||
"dependencies": {
|
||||
"rimraf": "~2.6.2",
|
||||
"mkdirp": "^0.5.1"
|
||||
},
|
||||
"keywords": [
|
||||
"temporary",
|
||||
"tmp",
|
||||
"temp",
|
||||
"tempdir",
|
||||
"tempfile",
|
||||
"tmpdir",
|
||||
"tmpfile"
|
||||
],
|
||||
"files": [
|
||||
"lib"
|
||||
],
|
||||
"devDependencies": {
|
||||
"mocha": "6.2.3"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/bruce/node-temp.git"
|
||||
},
|
||||
"scripts": {
|
||||
"test": "mocha test/temp-test.js"
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user