"Fossies" - the Fresh Open Source Software Archive

Member "Atom/resources/app/apm/node_modules/graceful-fs/graceful-fs.js" (8 Mar 2017, 6939 Bytes) of archive /windows/misc/atom-windows.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Javascript source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 var fs = require('fs')
    2 var polyfills = require('./polyfills.js')
    3 var legacy = require('./legacy-streams.js')
    4 var queue = []
    5 
    6 var util = require('util')
    7 
    8 function noop () {}
    9 
   10 var debug = noop
   11 if (util.debuglog)
   12   debug = util.debuglog('gfs4')
   13 else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
   14   debug = function() {
   15     var m = util.format.apply(util, arguments)
   16     m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
   17     console.error(m)
   18   }
   19 
   20 if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
   21   process.on('exit', function() {
   22     debug(queue)
   23     require('assert').equal(queue.length, 0)
   24   })
   25 }
   26 
   27 module.exports = patch(require('./fs.js'))
   28 if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH) {
   29   module.exports = patch(fs)
   30 }
   31 
   32 // Always patch fs.close/closeSync, because we want to
   33 // retry() whenever a close happens *anywhere* in the program.
   34 // This is essential when multiple graceful-fs instances are
   35 // in play at the same time.
   36 module.exports.close =
   37 fs.close = (function (fs$close) { return function (fd, cb) {
   38   return fs$close.call(fs, fd, function (err) {
   39     if (!err)
   40       retry()
   41 
   42     if (typeof cb === 'function')
   43       cb.apply(this, arguments)
   44   })
   45 }})(fs.close)
   46 
   47 module.exports.closeSync =
   48 fs.closeSync = (function (fs$closeSync) { return function (fd) {
   49   // Note that graceful-fs also retries when fs.closeSync() fails.
   50   // Looks like a bug to me, although it's probably a harmless one.
   51   var rval = fs$closeSync.apply(fs, arguments)
   52   retry()
   53   return rval
   54 }})(fs.closeSync)
   55 
   56 function patch (fs) {
   57   // Everything that references the open() function needs to be in here
   58   polyfills(fs)
   59   fs.gracefulify = patch
   60   fs.FileReadStream = ReadStream;  // Legacy name.
   61   fs.FileWriteStream = WriteStream;  // Legacy name.
   62   fs.createReadStream = createReadStream
   63   fs.createWriteStream = createWriteStream
   64   var fs$readFile = fs.readFile
   65   fs.readFile = readFile
   66   function readFile (path, options, cb) {
   67     if (typeof options === 'function')
   68       cb = options, options = null
   69 
   70     return go$readFile(path, options, cb)
   71 
   72     function go$readFile (path, options, cb) {
   73       return fs$readFile(path, options, function (err) {
   74         if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
   75           enqueue([go$readFile, [path, options, cb]])
   76         else {
   77           if (typeof cb === 'function')
   78             cb.apply(this, arguments)
   79           retry()
   80         }
   81       })
   82     }
   83   }
   84 
   85   var fs$writeFile = fs.writeFile
   86   fs.writeFile = writeFile
   87   function writeFile (path, data, options, cb) {
   88     if (typeof options === 'function')
   89       cb = options, options = null
   90 
   91     return go$writeFile(path, data, options, cb)
   92 
   93     function go$writeFile (path, data, options, cb) {
   94       return fs$writeFile(path, data, options, function (err) {
   95         if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
   96           enqueue([go$writeFile, [path, data, options, cb]])
   97         else {
   98           if (typeof cb === 'function')
   99             cb.apply(this, arguments)
  100           retry()
  101         }
  102       })
  103     }
  104   }
  105 
  106   var fs$appendFile = fs.appendFile
  107   if (fs$appendFile)
  108     fs.appendFile = appendFile
  109   function appendFile (path, data, options, cb) {
  110     if (typeof options === 'function')
  111       cb = options, options = null
  112 
  113     return go$appendFile(path, data, options, cb)
  114 
  115     function go$appendFile (path, data, options, cb) {
  116       return fs$appendFile(path, data, options, function (err) {
  117         if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
  118           enqueue([go$appendFile, [path, data, options, cb]])
  119         else {
  120           if (typeof cb === 'function')
  121             cb.apply(this, arguments)
  122           retry()
  123         }
  124       })
  125     }
  126   }
  127 
  128   var fs$readdir = fs.readdir
  129   fs.readdir = readdir
  130   function readdir (path, options, cb) {
  131     var args = [path]
  132     if (typeof options !== 'function') {
  133       args.push(options)
  134     } else {
  135       cb = options
  136     }
  137     args.push(go$readdir$cb)
  138 
  139     return go$readdir(args)
  140 
  141     function go$readdir$cb (err, files) {
  142       if (files && files.sort)
  143         files.sort()
  144 
  145       if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
  146         enqueue([go$readdir, [args]])
  147       else {
  148         if (typeof cb === 'function')
  149           cb.apply(this, arguments)
  150         retry()
  151       }
  152     }
  153   }
  154 
  155   function go$readdir (args) {
  156     return fs$readdir.apply(fs, args)
  157   }
  158 
  159   if (process.version.substr(0, 4) === 'v0.8') {
  160     var legStreams = legacy(fs)
  161     ReadStream = legStreams.ReadStream
  162     WriteStream = legStreams.WriteStream
  163   }
  164 
  165   var fs$ReadStream = fs.ReadStream
  166   ReadStream.prototype = Object.create(fs$ReadStream.prototype)
  167   ReadStream.prototype.open = ReadStream$open
  168 
  169   var fs$WriteStream = fs.WriteStream
  170   WriteStream.prototype = Object.create(fs$WriteStream.prototype)
  171   WriteStream.prototype.open = WriteStream$open
  172 
  173   fs.ReadStream = ReadStream
  174   fs.WriteStream = WriteStream
  175 
  176   function ReadStream (path, options) {
  177     if (this instanceof ReadStream)
  178       return fs$ReadStream.apply(this, arguments), this
  179     else
  180       return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
  181   }
  182 
  183   function ReadStream$open () {
  184     var that = this
  185     open(that.path, that.flags, that.mode, function (err, fd) {
  186       if (err) {
  187         if (that.autoClose)
  188           that.destroy()
  189 
  190         that.emit('error', err)
  191       } else {
  192         that.fd = fd
  193         that.emit('open', fd)
  194         that.read()
  195       }
  196     })
  197   }
  198 
  199   function WriteStream (path, options) {
  200     if (this instanceof WriteStream)
  201       return fs$WriteStream.apply(this, arguments), this
  202     else
  203       return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
  204   }
  205 
  206   function WriteStream$open () {
  207     var that = this
  208     open(that.path, that.flags, that.mode, function (err, fd) {
  209       if (err) {
  210         that.destroy()
  211         that.emit('error', err)
  212       } else {
  213         that.fd = fd
  214         that.emit('open', fd)
  215       }
  216     })
  217   }
  218 
  219   function createReadStream (path, options) {
  220     return new ReadStream(path, options)
  221   }
  222 
  223   function createWriteStream (path, options) {
  224     return new WriteStream(path, options)
  225   }
  226 
  227   var fs$open = fs.open
  228   fs.open = open
  229   function open (path, flags, mode, cb) {
  230     if (typeof mode === 'function')
  231       cb = mode, mode = null
  232 
  233     return go$open(path, flags, mode, cb)
  234 
  235     function go$open (path, flags, mode, cb) {
  236       return fs$open(path, flags, mode, function (err, fd) {
  237         if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
  238           enqueue([go$open, [path, flags, mode, cb]])
  239         else {
  240           if (typeof cb === 'function')
  241             cb.apply(this, arguments)
  242           retry()
  243         }
  244       })
  245     }
  246   }
  247 
  248   return fs
  249 }
  250 
  251 function enqueue (elem) {
  252   debug('ENQUEUE', elem[0].name, elem[1])
  253   queue.push(elem)
  254 }
  255 
  256 function retry () {
  257   var elem = queue.shift()
  258   if (elem) {
  259     debug('RETRY', elem[0].name, elem[1])
  260     elem[0].apply(null, elem[1])
  261   }
  262 }