Son CV dans un terminal web en Javascript! https://terminal-cv.gregandev.fr
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

199 lines
5.2 KiB

1 year ago
var fs = require('graceful-fs');
var Writable = require('readable-stream').Writable;
var util = require('util');
var MurmurHash3 = require('imurmurhash');
var iferr = require('iferr');
var crypto = require('crypto');
var threadId = require('./thread-id');
function murmurhex() {
var hash = MurmurHash3('');
for (var ii = 0; ii < arguments.length; ++ii) {
hash.hash('' + arguments[ii]);
}
return hash.result();
}
var invocations = 0;
function getTmpname(filename) {
return (
filename + '.' + murmurhex(__filename, process.pid, threadId, ++invocations)
);
}
var setImmediate = global.setImmediate || setTimeout;
module.exports = WriteStreamAtomic;
// Requirements:
// 1. Write everything written to the stream to a temp file.
// 2. If there are no errors:
// a. moves the temp file into its final destination
// b. emits `finish` & `closed` ONLY after the file is
// fully flushed and renamed.
// 3. If there's an error, removes the temp file.
util.inherits(WriteStreamAtomic, Writable);
function WriteStreamAtomic(path, options) {
if (!(this instanceof WriteStreamAtomic)) {
return new WriteStreamAtomic(path, options);
}
Writable.call(this, options);
this.__isWin =
options && options.hasOwnProperty('isWin')
? options.isWin
: process.platform === 'win32';
this.__atomicTarget = path;
this.__atomicTmp = getTmpname(path);
this.__atomicChown = options && options.chown;
this.__atomicClosed = false;
this.__atomicStream = fs.WriteStream(this.__atomicTmp, options);
this.__atomicStream.once('open', handleOpen(this));
this.__atomicStream.once('close', handleClose(this));
this.__atomicStream.once('error', handleError(this));
}
// We have to suppress default finish emitting, because ordinarily it
// would happen as soon as `end` is called on us and all of the
// data has been written to our target stream. So we suppress
// finish from being emitted here, and only emit it after our
// target stream is closed and we've moved everything around.
WriteStreamAtomic.prototype.emit = function(event) {
if (event === 'finish') return this.__atomicStream.end();
return Writable.prototype.emit.apply(this, arguments);
};
WriteStreamAtomic.prototype._write = function(buffer, encoding, cb) {
var flushed = this.__atomicStream.write(buffer, encoding);
if (flushed) return cb();
this.__atomicStream.once('drain', cb);
};
function handleOpen(writeStream) {
return function(fd) {
writeStream.emit('open', fd);
};
}
function handleClose(writeStream) {
return function() {
if (writeStream.__atomicClosed) return;
writeStream.__atomicClosed = true;
if (writeStream.__atomicChown) {
var uid = writeStream.__atomicChown.uid;
var gid = writeStream.__atomicChown.gid;
return fs.chown(
writeStream.__atomicTmp,
uid,
gid,
iferr(cleanup, moveIntoPlace),
);
} else {
moveIntoPlace();
}
};
function moveIntoPlace() {
fs.rename(
writeStream.__atomicTmp,
writeStream.__atomicTarget,
iferr(trapWindowsEPERM, end),
);
}
function trapWindowsEPERM(err) {
if (
writeStream.__isWin &&
err.syscall &&
err.syscall === 'rename' &&
err.code &&
err.code === 'EPERM'
) {
checkFileHashes(err);
} else {
cleanup(err);
}
}
function checkFileHashes(eperm) {
var inprocess = 2;
var tmpFileHash = crypto.createHash('sha512');
var targetFileHash = crypto.createHash('sha512');
fs.createReadStream(writeStream.__atomicTmp)
.on('data', function(data, enc) {
tmpFileHash.update(data, enc);
})
.on('error', fileHashError)
.on('end', fileHashComplete);
fs.createReadStream(writeStream.__atomicTarget)
.on('data', function(data, enc) {
targetFileHash.update(data, enc);
})
.on('error', fileHashError)
.on('end', fileHashComplete);
function fileHashError() {
if (inprocess === 0) return;
inprocess = 0;
cleanup(eperm);
}
function fileHashComplete() {
if (inprocess === 0) return;
if (--inprocess) return;
if (tmpFileHash.digest('hex') === targetFileHash.digest('hex')) {
return cleanup();
} else {
return cleanup(eperm);
}
}
}
function cleanup(err) {
fs.unlink(writeStream.__atomicTmp, function() {
if (err) {
writeStream.emit('error', err);
writeStream.emit('close');
} else {
end();
}
});
}
function end() {
// We have to use our parent class directly because we suppress `finish`
// events fired via our own emit method.
Writable.prototype.emit.call(writeStream, 'finish');
// Delay the close to provide the same temporal separation a physical
// file operation would have– that is, the close event is emitted only
// after the async close operation completes.
setImmediate(function() {
writeStream.emit('close');
});
}
}
function handleError(writeStream) {
return function(er) {
cleanupSync();
writeStream.emit('error', er);
writeStream.__atomicClosed = true;
writeStream.emit('close');
};
function cleanupSync() {
try {
fs.unlinkSync(writeStream.__atomicTmp);
} finally {
return;
}
}
}