| |
| module.exports = exports = install |
| |
| module.exports.test = { download: download, readCAFile: readCAFile } |
| |
| exports.usage = 'Install node development files for the specified node version.' |
| |
| /** |
| * Module dependencies. |
| */ |
| |
| var fs = require('graceful-fs') |
| , osenv = require('osenv') |
| , tar = require('tar') |
| , rm = require('rimraf') |
| , path = require('path') |
| , crypto = require('crypto') |
| , zlib = require('zlib') |
| , log = require('npmlog') |
| , semver = require('semver') |
| , fstream = require('fstream') |
| , request = require('request') |
| , minimatch = require('minimatch') |
| , mkdir = require('mkdirp') |
| , processRelease = require('./process-release') |
| , win = process.platform == 'win32' |
| |
| function install (gyp, argv, callback) { |
| |
| var release = processRelease(argv, gyp, process.version, process.release) |
| |
| // ensure no double-callbacks happen |
| function cb (err) { |
| if (cb.done) return |
| cb.done = true |
| if (err) { |
| log.warn('install', 'got an error, rolling back install') |
| // roll-back the install if anything went wrong |
| gyp.commands.remove([ release.versionDir ], function (err2) { |
| callback(err) |
| }) |
| } else { |
| callback(null, release.version) |
| } |
| } |
| |
| // Determine which node dev files version we are installing |
| log.verbose('install', 'input version string %j', release.version) |
| |
| if (!release.semver) { |
| // could not parse the version string with semver |
| return callback(new Error('Invalid version number: ' + release.version)) |
| } |
| |
| if (semver.lt(release.version, '0.8.0')) { |
| return callback(new Error('Minimum target version is `0.8.0` or greater. Got: ' + release.version)) |
| } |
| |
| // 0.x.y-pre versions are not published yet and cannot be installed. Bail. |
| if (release.semver.prerelease[0] === 'pre') { |
| log.verbose('detected "pre" node version', release.version) |
| if (gyp.opts.nodedir) { |
| log.verbose('--nodedir flag was passed; skipping install', gyp.opts.nodedir) |
| callback() |
| } else { |
| callback(new Error('"pre" versions of node cannot be installed, use the --nodedir flag instead')) |
| } |
| return |
| } |
| |
| // flatten version into String |
| log.verbose('install', 'installing version: %s', release.versionDir) |
| |
| // the directory where the dev files will be installed |
| var devDir = path.resolve(gyp.devDir, release.versionDir) |
| |
| // If '--ensure' was passed, then don't *always* install the version; |
| // check if it is already installed, and only install when needed |
| if (gyp.opts.ensure) { |
| log.verbose('install', '--ensure was passed, so won\'t reinstall if already installed') |
| fs.stat(devDir, function (err, stat) { |
| if (err) { |
| if (err.code == 'ENOENT') { |
| log.verbose('install', 'version not already installed, continuing with install', release.version) |
| go() |
| } else if (err.code == 'EACCES') { |
| eaccesFallback() |
| } else { |
| cb(err) |
| } |
| return |
| } |
| log.verbose('install', 'version is already installed, need to check "installVersion"') |
| var installVersionFile = path.resolve(devDir, 'installVersion') |
| fs.readFile(installVersionFile, 'ascii', function (err, ver) { |
| if (err && err.code != 'ENOENT') { |
| return cb(err) |
| } |
| var installVersion = parseInt(ver, 10) || 0 |
| log.verbose('got "installVersion"', installVersion) |
| log.verbose('needs "installVersion"', gyp.package.installVersion) |
| if (installVersion < gyp.package.installVersion) { |
| log.verbose('install', 'version is no good; reinstalling') |
| go() |
| } else { |
| log.verbose('install', 'version is good') |
| cb() |
| } |
| }) |
| }) |
| } else { |
| go() |
| } |
| |
| function getContentSha(res, callback) { |
| var shasum = crypto.createHash('sha256') |
| res.on('data', function (chunk) { |
| shasum.update(chunk) |
| }).on('end', function () { |
| callback(null, shasum.digest('hex')) |
| }) |
| } |
| |
| function go () { |
| |
| log.verbose('ensuring nodedir is created', devDir) |
| |
| // first create the dir for the node dev files |
| mkdir(devDir, function (err, created) { |
| if (err) { |
| if (err.code == 'EACCES') { |
| eaccesFallback() |
| } else { |
| cb(err) |
| } |
| return |
| } |
| |
| if (created) { |
| log.verbose('created nodedir', created) |
| } |
| |
| // now download the node tarball |
| var tarPath = gyp.opts.tarball |
| var badDownload = false |
| , extractCount = 0 |
| , gunzip = zlib.createGunzip() |
| , extracter = tar.Extract({ path: devDir, strip: 1, filter: isValid }) |
| |
| var contentShasums = {} |
| var expectShasums = {} |
| |
| // checks if a file to be extracted from the tarball is valid. |
| // only .h header files and the gyp files get extracted |
| function isValid () { |
| var name = this.path.substring(devDir.length + 1) |
| var isValid = valid(name) |
| if (name === '' && this.type === 'Directory') { |
| // the first directory entry is ok |
| return true |
| } |
| if (isValid) { |
| log.verbose('extracted file from tarball', name) |
| extractCount++ |
| } else { |
| // invalid |
| log.silly('ignoring from tarball', name) |
| } |
| return isValid |
| } |
| |
| gunzip.on('error', cb) |
| extracter.on('error', cb) |
| extracter.on('end', afterTarball) |
| |
| // download the tarball, gunzip and extract! |
| |
| if (tarPath) { |
| var input = fs.createReadStream(tarPath) |
| input.pipe(gunzip).pipe(extracter) |
| return |
| } |
| |
| try { |
| var req = download(gyp, process.env, release.tarballUrl) |
| } catch (e) { |
| return cb(e) |
| } |
| |
| // something went wrong downloading the tarball? |
| req.on('error', function (err) { |
| if (err.code === 'ENOTFOUND') { |
| return cb(new Error('This is most likely not a problem with node-gyp or the package itself and\n' + |
| 'is related to network connectivity. In most cases you are behind a proxy or have bad \n' + |
| 'network settings.')) |
| } |
| badDownload = true |
| cb(err) |
| }) |
| |
| req.on('close', function () { |
| if (extractCount === 0) { |
| cb(new Error('Connection closed while downloading tarball file')) |
| } |
| }) |
| |
| req.on('response', function (res) { |
| if (res.statusCode !== 200) { |
| badDownload = true |
| cb(new Error(res.statusCode + ' response downloading ' + release.tarballUrl)) |
| return |
| } |
| // content checksum |
| getContentSha(res, function (_, checksum) { |
| var filename = path.basename(release.tarballUrl).trim() |
| contentShasums[filename] = checksum |
| log.verbose('content checksum', filename, checksum) |
| }) |
| |
| // start unzipping and untaring |
| req.pipe(gunzip).pipe(extracter) |
| }) |
| |
| // invoked after the tarball has finished being extracted |
| function afterTarball () { |
| if (badDownload) return |
| if (extractCount === 0) { |
| return cb(new Error('There was a fatal problem while downloading/extracting the tarball')) |
| } |
| log.verbose('tarball', 'done parsing tarball') |
| var async = 0 |
| |
| if (win) { |
| // need to download node.lib |
| async++ |
| downloadNodeLib(deref) |
| } |
| |
| // write the "installVersion" file |
| async++ |
| var installVersionPath = path.resolve(devDir, 'installVersion') |
| fs.writeFile(installVersionPath, gyp.package.installVersion + '\n', deref) |
| |
| // Only download SHASUMS.txt if not using tarPath override |
| if (!tarPath) { |
| // download SHASUMS.txt |
| async++ |
| downloadShasums(deref) |
| } |
| |
| if (async === 0) { |
| // no async tasks required |
| cb() |
| } |
| |
| function deref (err) { |
| if (err) return cb(err) |
| |
| async-- |
| if (!async) { |
| log.verbose('download contents checksum', JSON.stringify(contentShasums)) |
| // check content shasums |
| for (var k in contentShasums) { |
| log.verbose('validating download checksum for ' + k, '(%s == %s)', contentShasums[k], expectShasums[k]) |
| if (contentShasums[k] !== expectShasums[k]) { |
| cb(new Error(k + ' local checksum ' + contentShasums[k] + ' not match remote ' + expectShasums[k])) |
| return |
| } |
| } |
| cb() |
| } |
| } |
| } |
| |
| function downloadShasums(done) { |
| log.verbose('check download content checksum, need to download `SHASUMS256.txt`...') |
| var shasumsPath = path.resolve(devDir, 'SHASUMS256.txt') |
| |
| log.verbose('checksum url', release.shasumsUrl) |
| try { |
| var req = download(gyp, process.env, release.shasumsUrl) |
| } catch (e) { |
| return cb(e) |
| } |
| |
| req.on('error', done) |
| req.on('response', function (res) { |
| if (res.statusCode !== 200) { |
| done(new Error(res.statusCode + ' status code downloading checksum')) |
| return |
| } |
| |
| var chunks = [] |
| res.on('data', function (chunk) { |
| chunks.push(chunk) |
| }) |
| res.on('end', function () { |
| var lines = Buffer.concat(chunks).toString().trim().split('\n') |
| lines.forEach(function (line) { |
| var items = line.trim().split(/\s+/) |
| if (items.length !== 2) return |
| |
| // 0035d18e2dcf9aad669b1c7c07319e17abfe3762 ./node-v0.11.4.tar.gz |
| var name = items[1].replace(/^\.\//, '') |
| expectShasums[name] = items[0] |
| }) |
| |
| log.verbose('checksum data', JSON.stringify(expectShasums)) |
| done() |
| }) |
| }) |
| } |
| |
| function downloadNodeLib (done) { |
| log.verbose('on Windows; need to download `' + release.name + '.lib`...') |
| var dir32 = path.resolve(devDir, 'ia32') |
| , dir64 = path.resolve(devDir, 'x64') |
| , libPath32 = path.resolve(dir32, release.name + '.lib') |
| , libPath64 = path.resolve(dir64, release.name + '.lib') |
| |
| log.verbose('32-bit ' + release.name + '.lib dir', dir32) |
| log.verbose('64-bit ' + release.name + '.lib dir', dir64) |
| log.verbose('`' + release.name + '.lib` 32-bit url', release.libUrl32) |
| log.verbose('`' + release.name + '.lib` 64-bit url', release.libUrl64) |
| |
| var async = 2 |
| mkdir(dir32, function (err) { |
| if (err) return done(err) |
| log.verbose('streaming 32-bit ' + release.name + '.lib to:', libPath32) |
| |
| try { |
| var req = download(gyp, process.env, release.libUrl32, cb) |
| } catch (e) { |
| return cb(e) |
| } |
| |
| req.on('error', done) |
| req.on('response', function (res) { |
| if (res.statusCode !== 200) { |
| done(new Error(res.statusCode + ' status code downloading 32-bit ' + release.name + '.lib')) |
| return |
| } |
| |
| getContentSha(res, function (_, checksum) { |
| contentShasums[release.libPath32] = checksum |
| log.verbose('content checksum', release.libPath32, checksum) |
| }) |
| |
| var ws = fs.createWriteStream(libPath32) |
| ws.on('error', cb) |
| req.pipe(ws) |
| }) |
| req.on('end', function () { |
| --async || done() |
| }) |
| }) |
| mkdir(dir64, function (err) { |
| if (err) return done(err) |
| log.verbose('streaming 64-bit ' + release.name + '.lib to:', libPath64) |
| |
| try { |
| var req = download(gyp, process.env, release.libUrl64, cb) |
| } catch (e) { |
| return cb(e) |
| } |
| |
| req.on('error', done) |
| req.on('response', function (res) { |
| if (res.statusCode !== 200) { |
| done(new Error(res.statusCode + ' status code downloading 64-bit ' + release.name + '.lib')) |
| return |
| } |
| |
| getContentSha(res, function (_, checksum) { |
| contentShasums[release.libPath64] = checksum |
| log.verbose('content checksum', release.libPath64, checksum) |
| }) |
| |
| var ws = fs.createWriteStream(libPath64) |
| ws.on('error', cb) |
| req.pipe(ws) |
| }) |
| req.on('end', function () { |
| --async || done() |
| }) |
| }) |
| } // downloadNodeLib() |
| |
| }) // mkdir() |
| |
| } // go() |
| |
| /** |
| * Checks if a given filename is "valid" for this installation. |
| */ |
| |
| function valid (file) { |
| // header files |
| return minimatch(file, '*.h', { matchBase: true }) || |
| minimatch(file, '*.gypi', { matchBase: true }) |
| } |
| |
| /** |
| * The EACCES fallback is a workaround for npm's `sudo` behavior, where |
| * it drops the permissions before invoking any child processes (like |
| * node-gyp). So what happens is the "nobody" user doesn't have |
| * permission to create the dev dir. As a fallback, make the tmpdir() be |
| * the dev dir for this installation. This is not ideal, but at least |
| * the compilation will succeed... |
| */ |
| |
| function eaccesFallback () { |
| var tmpdir = osenv.tmpdir() |
| gyp.devDir = path.resolve(tmpdir, '.node-gyp') |
| log.warn('EACCES', 'user "%s" does not have permission to access the dev dir "%s"', osenv.user(), devDir) |
| log.warn('EACCES', 'attempting to reinstall using temporary dev dir "%s"', gyp.devDir) |
| if (process.cwd() == tmpdir) { |
| log.verbose('tmpdir == cwd', 'automatically will remove dev files after to save disk space') |
| gyp.todo.push({ name: 'remove', args: argv }) |
| } |
| gyp.commands.install(argv, cb) |
| } |
| |
| } |
| |
| function download (gyp, env, url) { |
| log.http('GET', url) |
| |
| var requestOpts = { |
| uri: url |
| , headers: { |
| 'User-Agent': 'node-gyp v' + gyp.version + ' (node ' + process.version + ')' |
| } |
| } |
| |
| var cafile = gyp.opts.cafile |
| if (cafile) { |
| requestOpts.ca = readCAFile(cafile) |
| } |
| |
| // basic support for a proxy server |
| var proxyUrl = gyp.opts.proxy |
| || env.http_proxy |
| || env.HTTP_PROXY |
| || env.npm_config_proxy |
| if (proxyUrl) { |
| if (/^https?:\/\//i.test(proxyUrl)) { |
| log.verbose('download', 'using proxy url: "%s"', proxyUrl) |
| requestOpts.proxy = proxyUrl |
| } else { |
| log.warn('download', 'ignoring invalid "proxy" config setting: "%s"', proxyUrl) |
| } |
| } |
| |
| var req = request(requestOpts) |
| req.on('response', function (res) { |
| log.http(res.statusCode, url) |
| }) |
| |
| return req |
| } |
| |
| function readCAFile (filename) { |
| // The CA file can contain multiple certificates so split on certificate |
| // boundaries. [\S\s]*? is used to match everything including newlines. |
| var ca = fs.readFileSync(filename, 'utf8') |
| var re = /(-----BEGIN CERTIFICATE-----[\S\s]*?-----END CERTIFICATE-----)/g |
| return ca.match(re) |
| } |
