AlkantarClanX12
Current Path : /proc/thread-self/root/opt/alt/alt-nodejs6/root/lib/node_modules/npm/lib/utils/ |
Current File : //proc/thread-self/root/opt/alt/alt-nodejs6/root/lib/node_modules/npm/lib/utils/gently-rm.js |
// only remove the thing if it's a symlink into a specific folder. This is // a very common use-case of npm's, but not so common elsewhere. exports = module.exports = gentlyRm var resolve = require('path').resolve var dirname = require('path').dirname var normalize = require('path').normalize var validate = require('aproba') var log = require('npmlog') var lstat = require('graceful-fs').lstat var readlink = require('graceful-fs').readlink var isInside = require('path-is-inside') var vacuum = require('fs-vacuum') var chain = require('slide').chain var asyncMap = require('slide').asyncMap var readCmdShim = require('read-cmd-shim') var iferr = require('iferr') var npm = require('../npm.js') function gentlyRm (target, gently, base, cb) { if (!cb) { cb = base base = undefined } if (!cb) { cb = gently gently = false } log.silly( 'gentlyRm', target, 'is being', gently ? 'gently removed' : 'purged', base ? 'from base ' + base : '' ) // never rm the root, prefix, or bin dirs // // globals included because of `npm link` -- as far as the package // requesting the link is concerned, the linked package is always // installed globally var prefixes = [ npm.prefix, npm.globalPrefix, npm.dir, npm.root, npm.globalDir, npm.bin, npm.globalBin ] var targetPath = normalize(resolve(npm.prefix, target)) if (prefixes.indexOf(targetPath) !== -1) { log.verbose('gentlyRm', targetPath, "is part of npm and can't be removed") return cb(new Error('May not delete: ' + targetPath)) } var options = { log: log.silly.bind(log, 'vacuum-fs') } if (npm.config.get('force') || !gently) options.purge = true if (base) options.base = normalize(resolve(npm.prefix, base)) if (!gently) { log.verbose('gentlyRm', "don't care about contents; nuking", targetPath) return vacuum(targetPath, options, cb) } var parent = options.base = options.base || normalize(npm.prefix) // Do all the async work we'll need to do in order to tell if this is a // safe operation chain([ [isEverInside, parent, prefixes], [readLinkOrShim, targetPath], [isEverInside, targetPath, prefixes], [isEverInside, targetPath, [parent]] ], function (er, results) { if (er) { if (er.code === 'ENOENT') return cb() return cb(er) } var parentInfo = { path: parent, managed: results[0] } var targetInfo = { path: targetPath, symlink: results[1], managed: results[2], inParent: results[3] } isSafeToRm(parentInfo, targetInfo, iferr(cb, thenRemove)) function thenRemove (toRemove, removeBase) { if (!toRemove) return cb() if (removeBase) options.base = removeBase log.verbose('gentlyRm', options.purge ? 'Purging' : 'Vacuuming', toRemove, 'up to', options.base) return vacuum(toRemove, options, cb) } }) } exports._isSafeToRm = isSafeToRm function isSafeToRm (parent, target, cb) { log.silly('gentlyRm', 'parent.path =', parent.path) log.silly('gentlyRm', 'parent.managed =', parent.managed && parent.managed.target + ' is in ' + parent.managed.path) log.silly('gentlyRm', 'target.path = ', target.path) log.silly('gentlyRm', 'target.symlink =', target.symlink) log.silly('gentlyRm', 'target.managed =', target.managed && target.managed.target + ' is in ' + target.managed.path) log.silly('gentlyRm', 'target.inParent = ', target.inParent) // The parent directory or something it symlinks to must eventually be in // a folder that npm maintains. if (!parent.managed) { log.verbose('gentlyRm', parent.path, 'is not contained in any diretory npm is known to control or ' + 'any place they link to') return cb(clobberFail(target.path, 'containing path ' + parent.path + " isn't under npm's control")) } // The target or something it symlinks to must eventually be in the parent // or something the parent symlinks to if (target.inParent) { var actualTarget = target.inParent.target var targetsParent = target.inParent.path // if the target.path was what we found in some version of parent, remove // using that parent as the base if (target.path === actualTarget) { return cb(null, target.path, targetsParent) } else { // If something the target.path links to was what was found, just // remove target.path in the location it was found. return cb(null, target.path, dirname(target.path)) } } // If the target is in a managed directory and is in a symlink, but was // not in our parent that usually means someone else installed a bin file // with the same name as one of our bin files. if (target.managed && target.symlink) { log.warn('gentlyRm', 'not removing', target.path, "as it wasn't installed by", parent.path) return cb() } if (target.symlink) { return cb(clobberFail(target.path, target.symlink + ' symlink target is not controlled by npm ' + parent.path)) } else { return cb(clobberFail(target.path, 'is outside ' + parent.path + ' and not a link')) } } function clobberFail (target, msg) { validate('SS', arguments) var er = new Error('Refusing to delete ' + target + ': ' + msg) er.code = 'EEXIST' er.path = target return er } function isENOENT (err) { return err && err.code === 'ENOENT' } function notENOENT (err) { return !isENOENT(err) } function skipENOENT (cb) { return function (err, value) { if (isENOENT(err)) { return cb(null, false) } else { return cb(err, value) } } } function errorsToValues (fn) { return function () { var args = Array.prototype.slice.call(arguments) var cb = args.pop() args.push(function (err, value) { if (err) { return cb(null, err) } else { return cb(null, value) } }) fn.apply(null, args) } } function isNotError (value) { return !(value instanceof Error) } exports._isEverInside = isEverInside // return the first of path, where target (or anything it symlinks to) // isInside the path (or anything it symlinks to) function isEverInside (target, paths, cb) { validate('SAF', arguments) asyncMap(paths, errorsToValues(readAllLinks), iferr(cb, function (resolvedPaths) { var errorFree = resolvedPaths.filter(isNotError) if (errorFree.length === 0) { var badErrors = resolvedPaths.filter(notENOENT) if (badErrors.length === 0) { return cb(null, false) } else { return cb(badErrors[0]) } } readAllLinks(target, iferr(skipENOENT(cb), function (targets) { cb(null, areAnyInsideAny(targets, errorFree)) })) })) } exports._areAnyInsideAny = areAnyInsideAny // Return the first path found that any target is inside function areAnyInsideAny (targets, paths) { validate('AA', arguments) var toCheck = [] paths.forEach(function (path) { targets.forEach(function (target) { toCheck.push([target, path]) }) }) for (var ii = 0; ii < toCheck.length; ++ii) { var target = toCheck[ii][0] var path = toCheck[ii][1] var inside = isInside(target, path) if (!inside) log.silly('isEverInside', target, 'is not inside', path) if (inside && path) return inside && path && {target: target, path: path} } return false } exports._readAllLinks = readAllLinks // resolves chains of symlinks of unlimited depth, returning a list of paths // it's seen in the process when it hits either a symlink cycle or a // non-symlink function readAllLinks (path, cb) { validate('SF', arguments) var seen = {} _readAllLinks(path) function _readAllLinks (path) { if (seen[path]) return cb(null, Object.keys(seen)) seen[path] = true resolveSymlink(path, iferr(cb, _readAllLinks)) } } exports._resolveSymlink = resolveSymlink var resolvedPaths = {} function resolveSymlink (symlink, cb) { validate('SF', arguments) var cached = resolvedPaths[symlink] if (cached) return cb(null, cached) readLinkOrShim(symlink, iferr(cb, function (symlinkTarget) { if (symlinkTarget) { resolvedPaths[symlink] = resolve(dirname(symlink), symlinkTarget) } else { resolvedPaths[symlink] = symlink } return cb(null, resolvedPaths[symlink]) })) } exports._readLinkOrShim = readLinkOrShim function readLinkOrShim (path, cb) { validate('SF', arguments) lstat(path, iferr(cb, function (stat) { if (stat.isSymbolicLink()) { readlink(path, cb) } else { readCmdShim(path, function (er, source) { if (!er) return cb(null, source) // lstat wouldn't return an error on these, so we don't either. if (er.code === 'ENOTASHIM' || er.code === 'EISDIR') { return cb(null, null) } else { return cb(er) } }) } })) }