lepu-test-platform-web/node_modules/fs-write-stream-atomic/index.js

177 lines
5.0 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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')
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, ++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
}
}
}