Homec4science
Diffusion SHRINE MedCo Fork (feature/sprint2) Browse

shrine-medco/apps/steward-app/node/node_modules/npm/lib/cache/add-local-tarball.js
63198c668de0feature/sprint2

Last Change
Raw File

add-local-tarball.js
View Options

var mkdir = require('mkdirp')
var assert = require('assert')
var fs = require('graceful-fs')
var writeFileAtomic = require('write-file-atomic')
var path = require('path')
var sha = require('sha')
var npm = require('../npm.js')
var log = require('npmlog')
var tar = require('../utils/tar.js')
var pathIsInside = require('path-is-inside')
var getCacheStat = require('./get-stat.js')
var cachedPackageRoot = require('./cached-package-root.js')
var chownr = require('chownr')
var inflight = require('inflight')
var once = require('once')
var writeStreamAtomic = require('fs-write-stream-atomic')
var tempFilename = require('../utils/temp-filename.js')
var rimraf = require('rimraf')
var packageId = require('../utils/package-id.js')
module.exports = addLocalTarball
function addLocalTarball (p, pkgData, shasum, cb) {
assert(typeof p === 'string', 'must have path')
assert(typeof cb === 'function', 'must have callback')
if (!pkgData) pkgData = {}
// If we don't have a shasum yet, compute it.
if (!shasum) {
return sha.get(p, function (er, shasum) {
if (er) return cb(er)
log.silly('addLocalTarball', 'shasum (computed)', shasum)
addLocalTarball(p, pkgData, shasum, cb)
})
}
if (pathIsInside(p, npm.cache)) {
if (path.basename(p) !== 'package.tgz') {
return cb(new Error('Not a valid cache tarball name: ' + p))
}
log.verbose('addLocalTarball', 'adding from inside cache', p)
return addPlacedTarball(p, pkgData, shasum, cb)
}
addTmpTarball(p, pkgData, shasum, function (er, data) {
if (data) {
data._resolved = p
data._shasum = data._shasum || shasum
}
return cb(er, data)
})
}
function addPlacedTarball (p, pkgData, shasum, cb) {
assert(pkgData, 'should have package data by now')
assert(typeof cb === 'function', 'cb function required')
getCacheStat(function (er, cs) {
if (er) return cb(er)
return addPlacedTarball_(p, pkgData, cs.uid, cs.gid, shasum, cb)
})
}
function addPlacedTarball_ (p, pkgData, uid, gid, resolvedSum, cb) {
var folder = path.join(cachedPackageRoot(pkgData), 'package')
// First, make sure we have the shasum, if we don't already.
if (!resolvedSum) {
sha.get(p, function (er, shasum) {
if (er) return cb(er)
addPlacedTarball_(p, pkgData, uid, gid, shasum, cb)
})
return
}
mkdir(folder, function (er) {
if (er) return cb(er)
var pj = path.join(folder, 'package.json')
var json = JSON.stringify(pkgData, null, 2)
writeFileAtomic(pj, json, function (er) {
cb(er, pkgData)
})
})
}
function addTmpTarball (tgz, pkgData, shasum, cb) {
assert(typeof cb === 'function', 'must have callback function')
assert(shasum, 'must have shasum by now')
cb = inflight('addTmpTarball:' + tgz, cb)
if (!cb) return log.verbose('addTmpTarball', tgz, 'already in flight; not adding')
log.verbose('addTmpTarball', tgz, 'not in flight; adding')
// we already have the package info, so just move into place
if (pkgData && pkgData.name && pkgData.version) {
log.verbose(
'addTmpTarball',
'already have metadata; skipping unpack for',
packageId(pkgData)
)
return addTmpTarball_(tgz, pkgData, shasum, cb)
}
// This is a tarball we probably downloaded from the internet. The shasum's
// already been checked, but we haven't ever had a peek inside, so we unpack
// it here just to make sure it is what it says it is.
//
// NOTE: we might not have any clue what we think it is, for example if the
// user just did `npm install ./foo.tgz`
var target = tempFilename('unpack')
getCacheStat(function (er, cs) {
if (er) return cb(er)
log.verbose('addTmpTarball', 'validating metadata from', tgz)
tar.unpack(tgz, target, null, null, cs.uid, cs.gid, function (unpackEr, data) {
// cleanup the extracted package and move on with the metadata
rimraf(target, function () {
if (unpackEr) return cb(unpackEr)
// check that this is what we expected.
if (!data.name) {
return cb(new Error('No name provided'))
} else if (pkgData.name && data.name !== pkgData.name) {
return cb(new Error('Invalid Package: expected ' + pkgData.name +
' but found ' + data.name))
}
if (!data.version) {
return cb(new Error('No version provided'))
} else if (pkgData.version && data.version !== pkgData.version) {
return cb(new Error('Invalid Package: expected ' +
packageId(pkgData) +
' but found ' + packageId(data)))
}
addTmpTarball_(tgz, data, shasum, cb)
})
})
})
}
function addTmpTarball_ (tgz, data, shasum, cb) {
assert(typeof cb === 'function', 'must have callback function')
cb = once(cb)
assert(data.name, 'should have package name by now')
assert(data.version, 'should have package version by now')
var root = cachedPackageRoot(data)
var pkg = path.resolve(root, 'package')
var target = path.resolve(root, 'package.tgz')
getCacheStat(function (er, cs) {
if (er) return cb(er)
mkdir(pkg, function (er, created) {
// chown starting from the first dir created by mkdirp,
// or the root dir, if none had to be created, so that
// we know that we get all the children.
function chown () {
chownr(created || root, cs.uid, cs.gid, done)
}
if (er) return cb(er)
var read = fs.createReadStream(tgz)
var write = writeStreamAtomic(target, { mode: npm.modes.file })
var fin = cs.uid && cs.gid ? chown : done
read.on('error', cb).pipe(write).on('error', cb).on('close', fin)
})
})
function done () {
data._shasum = data._shasum || shasum
cb(null, data)
}
}
c4science · Help