Diffusion SHRINE MedCo Fork (patch/1.22.2.4) Browse

shrine-medco/shrine-webclient/src/main/html/node_modules/graceful-fs/graceful-fs.js
5f67068ab1f7patch/1.22.2.4

graceful-fs.js
View Options

			var fs = require('fs')
			var polyfills = require('./polyfills.js')
			var legacy = require('./legacy-streams.js')
			var queue = []

			var util = require('util')

			function noop () {}

			var debug = noop
			if (util.debuglog)
			debug = util.debuglog('gfs4')
			else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG \|\| ''))
			debug = function() {
			var m = util.format.apply(util, arguments)
			m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
			console.error(m)
			}

			if (/\bgfs4\b/i.test(process.env.NODE_DEBUG \|\| '')) {
			process.on('exit', function() {
			debug(queue)
			require('assert').equal(queue.length, 0)
			})
			}

			module.exports = patch(require('./fs.js'))
			if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH) {
			module.exports = patch(fs)
			}

			// Always patch fs.close/closeSync, because we want to
			// retry() whenever a close happens anywhere in the program.
			// This is essential when multiple graceful-fs instances are
			// in play at the same time.
			module.exports.close =
			fs.close = (function (fs$close) { return function (fd, cb) {
			return fs$close.call(fs, fd, function (err) {
			if (!err)
			retry()

			if (typeof cb === 'function')
			cb.apply(this, arguments)
			})
			}})(fs.close)

			module.exports.closeSync =
			fs.closeSync = (function (fs$closeSync) { return function (fd) {
			// Note that graceful-fs also retries when fs.closeSync() fails.
			// Looks like a bug to me, although it's probably a harmless one.
			var rval = fs$closeSync.apply(fs, arguments)
			retry()
			return rval
			}})(fs.closeSync)

			function patch (fs) {
			// Everything that references the open() function needs to be in here
			polyfills(fs)
			fs.gracefulify = patch
			fs.FileReadStream = ReadStream; // Legacy name.
			fs.FileWriteStream = WriteStream; // Legacy name.
			fs.createReadStream = createReadStream
			fs.createWriteStream = createWriteStream
			var fs$readFile = fs.readFile
			fs.readFile = readFile
			function readFile (path, options, cb) {
			if (typeof options === 'function')
			cb = options, options = null

			return go$readFile(path, options, cb)

			function go$readFile (path, options, cb) {
			return fs$readFile(path, options, function (err) {
			if (err && (err.code === 'EMFILE' \|\| err.code === 'ENFILE'))
			enqueue([go$readFile, [path, options, cb]])
			else {
			if (typeof cb === 'function')
			cb.apply(this, arguments)
			retry()
			}
			})
			}
			}

			var fs$writeFile = fs.writeFile
			fs.writeFile = writeFile
			function writeFile (path, data, options, cb) {
			if (typeof options === 'function')
			cb = options, options = null

			return go$writeFile(path, data, options, cb)

			function go$writeFile (path, data, options, cb) {
			return fs$writeFile(path, data, options, function (err) {
			if (err && (err.code === 'EMFILE' \|\| err.code === 'ENFILE'))
			enqueue([go$writeFile, [path, data, options, cb]])
			else {
			if (typeof cb === 'function')
			cb.apply(this, arguments)
			retry()
			}
			})
			}
			}

			var fs$appendFile = fs.appendFile
			if (fs$appendFile)
			fs.appendFile = appendFile
			function appendFile (path, data, options, cb) {
			if (typeof options === 'function')
			cb = options, options = null

			return go$appendFile(path, data, options, cb)

			function go$appendFile (path, data, options, cb) {
			return fs$appendFile(path, data, options, function (err) {
			if (err && (err.code === 'EMFILE' \|\| err.code === 'ENFILE'))
			enqueue([go$appendFile, [path, data, options, cb]])
			else {
			if (typeof cb === 'function')
			cb.apply(this, arguments)
			retry()
			}
			})
			}
			}

			var fs$readdir = fs.readdir
			fs.readdir = readdir
			function readdir (path, cb) {
			return go$readdir(path, cb)

			function go$readdir () {
			return fs$readdir(path, function (err, files) {
			if (files && files.sort)
			files.sort(); // Backwards compatibility with graceful-fs.

			if (err && (err.code === 'EMFILE' \|\| err.code === 'ENFILE'))
			enqueue([go$readdir, [path, cb]])
			else {
			if (typeof cb === 'function')
			cb.apply(this, arguments)
			retry()
			}
			})
			}
			}


			if (process.version.substr(0, 4) === 'v0.8') {
			var legStreams = legacy(fs)
			ReadStream = legStreams.ReadStream
			WriteStream = legStreams.WriteStream
			}

			var fs$ReadStream = fs.ReadStream
			ReadStream.prototype = Object.create(fs$ReadStream.prototype)
			ReadStream.prototype.open = ReadStream$open

			var fs$WriteStream = fs.WriteStream
			WriteStream.prototype = Object.create(fs$WriteStream.prototype)
			WriteStream.prototype.open = WriteStream$open

			fs.ReadStream = ReadStream
			fs.WriteStream = WriteStream

			function ReadStream (path, options) {
			if (this instanceof ReadStream)
			return fs$ReadStream.apply(this, arguments), this
			else
			return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
			}

			function ReadStream$open () {
			var that = this
			open(that.path, that.flags, that.mode, function (err, fd) {
			if (err) {
			if (that.autoClose)
			that.destroy()

			that.emit('error', err)
			} else {
			that.fd = fd
			that.emit('open', fd)
			that.read()
			}
			})
			}

			function WriteStream (path, options) {
			if (this instanceof WriteStream)
			return fs$WriteStream.apply(this, arguments), this
			else
			return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
			}

			function WriteStream$open () {
			var that = this
			open(that.path, that.flags, that.mode, function (err, fd) {
			if (err) {
			that.destroy()
			that.emit('error', err)
			} else {
			that.fd = fd
			that.emit('open', fd)
			}
			})
			}

			function createReadStream (path, options) {
			return new ReadStream(path, options)
			}

			function createWriteStream (path, options) {
			return new WriteStream(path, options)
			}

			var fs$open = fs.open
			fs.open = open
			function open (path, flags, mode, cb) {
			if (typeof mode === 'function')
			cb = mode, mode = null

			return go$open(path, flags, mode, cb)

			function go$open (path, flags, mode, cb) {
			return fs$open(path, flags, mode, function (err, fd) {
			if (err && (err.code === 'EMFILE' \|\| err.code === 'ENFILE'))
			enqueue([go$open, [path, flags, mode, cb]])
			else {
			if (typeof cb === 'function')
			cb.apply(this, arguments)
			retry()
			}
			})
			}
			}

			return fs
			}

			function enqueue (elem) {
			debug('ENQUEUE', elem[0].name, elem[1])
			queue.push(elem)
			}

			function retry () {
			var elem = queue.shift()
			if (elem) {
			debug('RETRY', elem[0].name, elem[1])
			elem[0].apply(null, elem[1])
			}
			}