return fs$close.call(fs, fd, function (err) {
// This function uses the graceful-fs shared queue
if (!err) {
- retry()
+ resetQueue()
}
if (typeof cb === 'function')
function closeSync (fd) {
// This function uses the graceful-fs shared queue
fs$closeSync.apply(fs, arguments)
- retry()
+ resetQueue()
}
Object.defineProperty(closeSync, previousSymbol, {
return go$readFile(path, options, cb)
- function go$readFile (path, options, cb) {
+ function go$readFile (path, options, cb, startTime) {
return fs$readFile(path, options, function (err) {
if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$readFile, [path, options, cb]])
+ enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()])
else {
if (typeof cb === 'function')
cb.apply(this, arguments)
- retry()
}
})
}
return go$writeFile(path, data, options, cb)
- function go$writeFile (path, data, options, cb) {
+ function go$writeFile (path, data, options, cb, startTime) {
return fs$writeFile(path, data, options, function (err) {
if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$writeFile, [path, data, options, cb]])
+ enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
else {
if (typeof cb === 'function')
cb.apply(this, arguments)
- retry()
}
})
}
return go$appendFile(path, data, options, cb)
- function go$appendFile (path, data, options, cb) {
+ function go$appendFile (path, data, options, cb, startTime) {
return fs$appendFile(path, data, options, function (err) {
if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$appendFile, [path, data, options, cb]])
+ enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
else {
if (typeof cb === 'function')
cb.apply(this, arguments)
- retry()
}
})
}
cb = flags
flags = 0
}
- return fs$copyFile(src, dest, flags, function (err) {
- if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([fs$copyFile, [src, dest, flags, cb]])
- else {
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- retry()
- }
- })
+ return go$copyFile(src, dest, flags, cb)
+
+ function go$copyFile (src, dest, flags, cb, startTime) {
+ return fs$copyFile(src, dest, flags, function (err) {
+ if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+ enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()])
+ else {
+ if (typeof cb === 'function')
+ cb.apply(this, arguments)
+ }
+ })
+ }
}
var fs$readdir = fs.readdir
fs.readdir = readdir
function readdir (path, options, cb) {
- var args = [path]
- if (typeof options !== 'function') {
- args.push(options)
- } else {
- cb = options
- }
- args.push(go$readdir$cb)
-
- return go$readdir(args)
+ if (typeof options === 'function')
+ cb = options, options = null
- function go$readdir$cb (err, files) {
- if (files && files.sort)
- files.sort()
+ return go$readdir(path, options, cb)
- if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$readdir, [args]])
+ function go$readdir (path, options, cb, startTime) {
+ return fs$readdir(path, options, function (err, files) {
+ if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+ enqueue([go$readdir, [path, options, cb], err, startTime || Date.now(), Date.now()])
+ else {
+ if (files && files.sort)
+ files.sort()
- else {
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- retry()
- }
+ if (typeof cb === 'function')
+ cb.call(this, err, files)
+ }
+ })
}
}
- function go$readdir (args) {
- return fs$readdir.apply(fs, args)
- }
-
if (process.version.substr(0, 4) === 'v0.8') {
var legStreams = legacy(fs)
ReadStream = legStreams.ReadStream
return go$open(path, flags, mode, cb)
- function go$open (path, flags, mode, cb) {
+ function go$open (path, flags, mode, cb, startTime) {
return fs$open(path, flags, mode, function (err, fd) {
if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$open, [path, flags, mode, cb]])
+ enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()])
else {
if (typeof cb === 'function')
cb.apply(this, arguments)
- retry()
}
})
}
function enqueue (elem) {
debug('ENQUEUE', elem[0].name, elem[1])
fs[gracefulQueue].push(elem)
+ retry()
+}
+
+// keep track of the timeout between retry() calls
+var retryTimer
+
+// reset the startTime and lastTime to now
+// this resets the start of the 60 second overall timeout as well as the
+// delay between attempts so that we'll retry these jobs sooner
+function resetQueue () {
+ var now = Date.now()
+ for (var i = 0; i < fs[gracefulQueue].length; ++i) {
+ // entries that are only a length of 2 are from an older version, don't
+ // bother modifying those since they'll be retried anyway.
+ if (fs[gracefulQueue][i].length > 2) {
+ fs[gracefulQueue][i][3] = now // startTime
+ fs[gracefulQueue][i][4] = now // lastTime
+ }
+ }
+ // call retry to make sure we're actively processing the queue
+ retry()
}
function retry () {
+ // clear the timer and remove it to help prevent unintended concurrency
+ clearTimeout(retryTimer)
+ retryTimer = undefined
+
+ if (fs[gracefulQueue].length === 0)
+ return
+
var elem = fs[gracefulQueue].shift()
- if (elem) {
- debug('RETRY', elem[0].name, elem[1])
- elem[0].apply(null, elem[1])
+ var fn = elem[0]
+ var args = elem[1]
+ // these items may be unset if they were added by an older graceful-fs
+ var err = elem[2]
+ var startTime = elem[3]
+ var lastTime = elem[4]
+
+ // if we don't have a startTime we have no way of knowing if we've waited
+ // long enough, so go ahead and retry this item now
+ if (startTime === undefined) {
+ debug('RETRY', fn.name, args)
+ fn.apply(null, args)
+ } else if (Date.now() - startTime >= 60000) {
+ // it's been more than 60 seconds total, bail now
+ debug('TIMEOUT', fn.name, args)
+ var cb = args.pop()
+ if (typeof cb === 'function')
+ cb.call(null, err)
+ } else {
+ // the amount of time between the last attempt and right now
+ var sinceAttempt = Date.now() - lastTime
+ // the amount of time between when we first tried, and when we last tried
+ // rounded up to at least 1
+ var sinceStart = Math.max(lastTime - startTime, 1)
+ // backoff. wait longer than the total time we've been retrying, but only
+ // up to a maximum of 100ms
+ var desiredDelay = Math.min(sinceStart * 1.2, 100)
+ // it's been long enough since the last retry, do it again
+ if (sinceAttempt >= desiredDelay) {
+ debug('RETRY', fn.name, args)
+ fn.apply(null, args.concat([startTime]))
+ } else {
+ // if we can't do this job yet, push it to the end of the queue
+ // and let the next iteration check again
+ fs[gracefulQueue].push(elem)
+ }
+ }
+
+ // schedule our next run if one isn't already scheduled
+ if (retryTimer === undefined) {
+ retryTimer = setTimeout(retry, 0)
}
}
projects / dotfiles / .git / blobdiff