whoami7 - Manager
:
/
opt
/
alt
/
alt-nodejs6
/
root
/
usr
/
lib
/
node_modules
/
npm
/
node_modules
/
lockfile
/
Upload File:
files >> //opt/alt/alt-nodejs6/root/usr/lib/node_modules/npm/node_modules/lockfile/lockfile.js
var fs = require('fs') var wx = 'wx' if (process.version.match(/^v0\.[0-6]/)) { var c = require('constants') wx = c.O_TRUNC | c.O_CREAT | c.O_WRONLY | c.O_EXCL } var os = require('os') exports.filetime = 'ctime' if (os.platform() == "win32") { exports.filetime = 'mtime' } var debug var util = require('util') if (util.debuglog) debug = util.debuglog('LOCKFILE') else if (/\blockfile\b/i.test(process.env.NODE_DEBUG)) debug = function() { var msg = util.format.apply(util, arguments) console.error('LOCKFILE %d %s', process.pid, msg) } else debug = function() {} var locks = {} function hasOwnProperty (obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop) } process.on('exit', function () { debug('exit listener') // cleanup Object.keys(locks).forEach(exports.unlockSync) }) // XXX https://github.com/joyent/node/issues/3555 // Remove when node 0.8 is deprecated. if (/^v0\.[0-8]\./.test(process.version)) { debug('uncaughtException, version = %s', process.version) process.on('uncaughtException', function H (er) { debug('uncaughtException') var l = process.listeners('uncaughtException').filter(function (h) { return h !== H }) if (!l.length) { // cleanup try { Object.keys(locks).forEach(exports.unlockSync) } catch (e) {} process.removeListener('uncaughtException', H) throw er } }) } exports.unlock = function (path, cb) { debug('unlock', path) // best-effort. unlocking an already-unlocked lock is a noop delete locks[path] fs.unlink(path, function (unlinkEr) { cb() }) } exports.unlockSync = function (path) { debug('unlockSync', path) // best-effort. unlocking an already-unlocked lock is a noop try { fs.unlinkSync(path) } catch (er) {} delete locks[path] } // if the file can be opened in readonly mode, then it's there. // if the error is something other than ENOENT, then it's not. exports.check = function (path, opts, cb) { if (typeof opts === 'function') cb = opts, opts = {} debug('check', path, opts) fs.open(path, 'r', function (er, fd) { if (er) { if (er.code !== 'ENOENT') return cb(er) return cb(null, false) } if (!opts.stale) { return fs.close(fd, function (er) { return cb(er, true) }) } fs.fstat(fd, function (er, st) { if (er) return fs.close(fd, function (er2) { return cb(er) }) fs.close(fd, function (er) { var age = Date.now() - st[exports.filetime].getTime() return cb(er, age <= opts.stale) }) }) }) } exports.checkSync = function (path, opts) { opts = opts || {} debug('checkSync', path, opts) if (opts.wait) { throw new Error('opts.wait not supported sync for obvious reasons') } try { var fd = fs.openSync(path, 'r') } catch (er) { if (er.code !== 'ENOENT') throw er return false } if (!opts.stale) { try { fs.closeSync(fd) } catch (er) {} return true } // file exists. however, might be stale if (opts.stale) { try { var st = fs.fstatSync(fd) } finally { fs.closeSync(fd) } var age = Date.now() - st[exports.filetime].getTime() return (age <= opts.stale) } } var req = 1 exports.lock = function (path, opts, cb) { if (typeof opts === 'function') cb = opts, opts = {} opts.req = opts.req || req++ debug('lock', path, opts) opts.start = opts.start || Date.now() if (typeof opts.retries === 'number' && opts.retries > 0) { debug('has retries', opts.retries) var retries = opts.retries opts.retries = 0 cb = (function (orig) { return function cb (er, fd) { debug('retry-mutated callback') retries -= 1 if (!er || retries < 0) return orig(er, fd) debug('lock retry', path, opts) if (opts.retryWait) setTimeout(retry, opts.retryWait) else retry() function retry () { opts.start = Date.now() debug('retrying', opts.start) exports.lock(path, opts, cb) } }})(cb) } // try to engage the lock. // if this succeeds, then we're in business. fs.open(path, wx, function (er, fd) { if (!er) { debug('locked', path, fd) locks[path] = fd return fs.close(fd, function () { return cb() }) } // something other than "currently locked" // maybe eperm or something. if (er.code !== 'EEXIST') return cb(er) // someone's got this one. see if it's valid. if (!opts.stale) return notStale(er, path, opts, cb) return maybeStale(er, path, opts, false, cb) }) } // Staleness checking algorithm // 1. acquire $lock, fail // 2. stat $lock, find that it is stale // 3. acquire $lock.STALE // 4. stat $lock, assert that it is still stale // 5. unlink $lock // 6. link $lock.STALE $lock // 7. unlink $lock.STALE // On any failure, clean up whatever we've done, and raise the error. function maybeStale (originalEr, path, opts, hasStaleLock, cb) { fs.stat(path, function (statEr, st) { if (statEr) { if (statEr.code === 'ENOENT') { // expired already! opts.stale = false debug('lock stale enoent retry', path, opts) exports.lock(path, opts, cb) return } return cb(statEr) } var age = Date.now() - st[exports.filetime].getTime() if (age <= opts.stale) return notStale(originalEr, path, opts, cb) debug('lock stale', path, opts) if (hasStaleLock) { exports.unlock(path, function (er) { if (er) return cb(er) debug('lock stale retry', path, opts) fs.link(path + '.STALE', path, function (er) { fs.unlink(path + '.STALE', function () { // best effort. if the unlink fails, oh well. cb(er) }) }) }) } else { debug('acquire .STALE file lock', opts) exports.lock(path + '.STALE', opts, function (er) { if (er) return cb(er) maybeStale(originalEr, path, opts, true, cb) }) } }) } function notStale (er, path, opts, cb) { debug('notStale', path, opts) // if we can't wait, then just call it a failure if (typeof opts.wait !== 'number' || opts.wait <= 0) return cb(er) // poll for some ms for the lock to clear var now = Date.now() var start = opts.start || now var end = start + opts.wait if (end <= now) return cb(er) debug('now=%d, wait until %d (delta=%d)', start, end, end-start) var wait = Math.min(end - start, opts.pollPeriod || 100) var timer = setTimeout(poll, wait) function poll () { debug('notStale, polling', path, opts) exports.lock(path, opts, cb) } } exports.lockSync = function (path, opts) { opts = opts || {} opts.req = opts.req || req++ debug('lockSync', path, opts) if (opts.wait || opts.retryWait) { throw new Error('opts.wait not supported sync for obvious reasons') } try { var fd = fs.openSync(path, wx) locks[path] = fd try { fs.closeSync(fd) } catch (er) {} debug('locked sync!', path, fd) return } catch (er) { if (er.code !== 'EEXIST') return retryThrow(path, opts, er) if (opts.stale) { var st = fs.statSync(path) var ct = st[exports.filetime].getTime() if (!(ct % 1000) && (opts.stale % 1000)) { // probably don't have subsecond resolution. // round up the staleness indicator. // Yes, this will be wrong 1/1000 times on platforms // with subsecond stat precision, but that's acceptable // in exchange for not mistakenly removing locks on // most other systems. opts.stale = 1000 * Math.ceil(opts.stale / 1000) } var age = Date.now() - ct if (age > opts.stale) { debug('lockSync stale', path, opts, age) exports.unlockSync(path) return exports.lockSync(path, opts) } } // failed to lock! debug('failed to lock', path, opts, er) return retryThrow(path, opts, er) } } function retryThrow (path, opts, er) { if (typeof opts.retries === 'number' && opts.retries > 0) { var newRT = opts.retries - 1 debug('retryThrow', path, opts, newRT) opts.retries = newRT return exports.lockSync(path, opts) } throw er }
Copyright ©2021 || Defacer Indonesia