0407feba0e8bdb6722244fa1cd432d365c33cfd2
[platform/upstream/nodejs.git] / deps / npm / node_modules / node-gyp / lib / install.js
1
2 module.exports = exports = install
3
4 exports.usage = 'Install node development files for the specified node version.'
5
6 /**
7  * Module dependencies.
8  */
9
10 var fs = require('graceful-fs')
11   , osenv = require('osenv')
12   , tar = require('tar')
13   , rm = require('rimraf')
14   , path = require('path')
15   , crypto = require('crypto')
16   , zlib = require('zlib')
17   , log = require('npmlog')
18   , semver = require('semver')
19   , fstream = require('fstream')
20   , request = require('request')
21   , minimatch = require('minimatch')
22   , mkdir = require('mkdirp')
23   , win = process.platform == 'win32'
24
25 function install (gyp, argv, callback) {
26
27   // ensure no double-callbacks happen
28   function cb (err) {
29     if (cb.done) return
30     cb.done = true
31     if (err) {
32       log.warn('install', 'got an error, rolling back install')
33       // roll-back the install if anything went wrong
34       gyp.commands.remove([ version ], function (err2) {
35         callback(err)
36       })
37     } else {
38       callback(null, version)
39     }
40   }
41
42   var distUrl = gyp.opts['dist-url'] || gyp.opts.disturl || 'https://iojs.org/dist'
43
44
45   // Determine which node dev files version we are installing
46   var versionStr = argv[0] || gyp.opts.target || process.version
47   log.verbose('install', 'input version string %j', versionStr)
48
49   // parse the version to normalize and ensure it's valid
50   var version = semver.parse(versionStr)
51   if (!version) {
52     return callback(new Error('Invalid version number: ' + versionStr))
53   }
54
55   if (semver.lt(versionStr, '0.8.0')) {
56     return callback(new Error('Minimum target version is `0.8.0` or greater. Got: ' + versionStr))
57   }
58
59   // 0.x.y-pre versions are not published yet and cannot be installed. Bail.
60   if (version.prerelease[0] === 'pre') {
61     log.verbose('detected "pre" node version', versionStr)
62     if (gyp.opts.nodedir) {
63       log.verbose('--nodedir flag was passed; skipping install', gyp.opts.nodedir)
64       callback()
65     } else {
66       callback(new Error('"pre" versions of node cannot be installed, use the --nodedir flag instead'))
67     }
68     return
69   }
70
71   // flatten version into String
72   version = version.version
73   log.verbose('install', 'installing version: %s', version)
74
75   // distributions starting with 0.10.0 contain sha256 checksums
76   var checksumAlgo = semver.gte(version, '0.10.0') ? 'sha256' : 'sha1'
77
78   // the directory where the dev files will be installed
79   var devDir = path.resolve(gyp.devDir, version)
80
81   // If '--ensure' was passed, then don't *always* install the version;
82   // check if it is already installed, and only install when needed
83   if (gyp.opts.ensure) {
84     log.verbose('install', '--ensure was passed, so won\'t reinstall if already installed')
85     fs.stat(devDir, function (err, stat) {
86       if (err) {
87         if (err.code == 'ENOENT') {
88           log.verbose('install', 'version not already installed, continuing with install', version)
89           go()
90         } else if (err.code == 'EACCES') {
91           eaccesFallback()
92         } else {
93           cb(err)
94         }
95         return
96       }
97       log.verbose('install', 'version is already installed, need to check "installVersion"')
98       var installVersionFile = path.resolve(devDir, 'installVersion')
99       fs.readFile(installVersionFile, 'ascii', function (err, ver) {
100         if (err && err.code != 'ENOENT') {
101           return cb(err)
102         }
103         var installVersion = parseInt(ver, 10) || 0
104         log.verbose('got "installVersion"', installVersion)
105         log.verbose('needs "installVersion"', gyp.package.installVersion)
106         if (installVersion < gyp.package.installVersion) {
107           log.verbose('install', 'version is no good; reinstalling')
108           go()
109         } else {
110           log.verbose('install', 'version is good')
111           cb()
112         }
113       })
114     })
115   } else {
116     go()
117   }
118
119   function download (url) {
120     log.http('GET', url)
121
122     var req = null
123     var requestOpts = {
124         uri: url
125       , headers: {
126           'User-Agent': 'node-gyp v' + gyp.version + ' (node ' + process.version + ')'
127         }
128     }
129
130     // basic support for a proxy server
131     var proxyUrl = gyp.opts.proxy
132                 || process.env.http_proxy
133                 || process.env.HTTP_PROXY
134                 || process.env.npm_config_proxy
135     if (proxyUrl) {
136       if (/^https?:\/\//i.test(proxyUrl)) {
137         log.verbose('download', 'using proxy url: "%s"', proxyUrl)
138         requestOpts.proxy = proxyUrl
139       } else {
140         log.warn('download', 'ignoring invalid "proxy" config setting: "%s"', proxyUrl)
141       }
142     }
143     try {
144       // The "request" constructor can throw sometimes apparently :(
145       // See: https://github.com/TooTallNate/node-gyp/issues/114
146       req = request(requestOpts)
147     } catch (e) {
148       cb(e)
149     }
150     if (req) {
151       req.on('response', function (res) {
152         log.http(res.statusCode, url)
153       })
154     }
155     return req
156   }
157
158   function getContentSha(res, callback) {
159     var shasum = crypto.createHash(checksumAlgo)
160     res.on('data', function (chunk) {
161       shasum.update(chunk)
162     }).on('end', function () {
163       callback(null, shasum.digest('hex'))
164     })
165   }
166
167   function go () {
168
169     log.verbose('ensuring nodedir is created', devDir)
170
171     // first create the dir for the node dev files
172     mkdir(devDir, function (err, created) {
173       if (err) {
174         if (err.code == 'EACCES') {
175           eaccesFallback()
176         } else {
177           cb(err)
178         }
179         return
180       }
181
182       if (created) {
183         log.verbose('created nodedir', created)
184       }
185
186       // now download the node tarball
187       var tarPath = gyp.opts['tarball']
188       var tarballUrl = tarPath ? tarPath : distUrl + '/v' + version + '/iojs-v' + version + '.tar.gz'
189         , badDownload = false
190         , extractCount = 0
191         , gunzip = zlib.createGunzip()
192         , extracter = tar.Extract({ path: devDir, strip: 1, filter: isValid })
193
194       var contentShasums = {}
195       var expectShasums = {}
196
197       // checks if a file to be extracted from the tarball is valid.
198       // only .h header files and the gyp files get extracted
199       function isValid () {
200         var name = this.path.substring(devDir.length + 1)
201         var isValid = valid(name)
202         if (name === '' && this.type === 'Directory') {
203           // the first directory entry is ok
204           return true
205         }
206         if (isValid) {
207           log.verbose('extracted file from tarball', name)
208           extractCount++
209         } else {
210           // invalid
211           log.silly('ignoring from tarball', name)
212         }
213         return isValid
214       }
215
216       gunzip.on('error', cb)
217       extracter.on('error', cb)
218       extracter.on('end', afterTarball)
219
220       // download the tarball, gunzip and extract!
221
222       if (tarPath) {
223         var input = fs.createReadStream(tarballUrl)
224         input.pipe(gunzip).pipe(extracter)
225         return
226       }
227
228       var req = download(tarballUrl)
229       if (!req) return
230
231       // something went wrong downloading the tarball?
232       req.on('error', function (err) {
233         if (err.code === 'ENOTFOUND') {
234           return cb(new Error('This is most likely not a problem with node-gyp or the package itself and\n' +
235             'is related to network connectivity. In most cases you are behind a proxy or have bad \n' +
236             'network settings.'))
237         }
238         badDownload = true
239         cb(err)
240       })
241
242       req.on('close', function () {
243         if (extractCount === 0) {
244           cb(new Error('Connection closed while downloading tarball file'))
245         }
246       })
247
248       req.on('response', function (res) {
249         if (res.statusCode !== 200) {
250           badDownload = true
251           cb(new Error(res.statusCode + ' response dowloading ' + tarballUrl))
252           return
253         }
254         // content checksum
255         getContentSha(res, function (_, checksum) {
256           var filename = path.basename(tarballUrl).trim()
257           contentShasums[filename] = checksum
258           log.verbose('content checksum', filename, checksum)
259         })
260
261         // start unzipping and untaring
262         req.pipe(gunzip).pipe(extracter)
263       })
264
265       // invoked after the tarball has finished being extracted
266       function afterTarball () {
267         if (badDownload) return
268         if (extractCount === 0) {
269           return cb(new Error('There was a fatal problem while downloading/extracting the tarball'))
270         }
271         log.verbose('tarball', 'done parsing tarball')
272         var async = 0
273
274         if (win) {
275           // need to download iojs.lib
276           async++
277           downloadNodeLib(deref)
278         }
279
280         // write the "installVersion" file
281         async++
282         var installVersionPath = path.resolve(devDir, 'installVersion')
283         fs.writeFile(installVersionPath, gyp.package.installVersion + '\n', deref)
284
285         // Only download SHASUMS.txt if not using tarPath override
286         if (!tarPath) {
287           // download SHASUMS.txt
288           async++
289           downloadShasums(deref)
290         }
291
292         if (async === 0) {
293           // no async tasks required
294           cb()
295         }
296
297         function deref (err) {
298           if (err) return cb(err)
299
300           async--
301           if (!async) {
302             log.verbose('download contents checksum', JSON.stringify(contentShasums))
303             // check content shasums
304             for (var k in contentShasums) {
305               log.verbose('validating download checksum for ' + k, '(%s == %s)', contentShasums[k], expectShasums[k])
306               if (contentShasums[k] !== expectShasums[k]) {
307                 cb(new Error(k + ' local checksum ' + contentShasums[k] + ' not match remote ' + expectShasums[k]))
308                 return
309               }
310             }
311             cb()
312           }
313         }
314       }
315
316       function downloadShasums(done) {
317         var shasumsFile = (checksumAlgo === 'sha256') ? 'SHASUMS256.txt' : 'SHASUMS.txt'
318         log.verbose('check download content checksum, need to download `' + shasumsFile + '`...')
319         var shasumsPath = path.resolve(devDir, shasumsFile)
320           , shasumsUrl = distUrl + '/v' + version + '/' + shasumsFile
321
322         log.verbose('checksum url', shasumsUrl)
323         var req = download(shasumsUrl)
324         if (!req) return
325         req.on('error', done)
326         req.on('response', function (res) {
327           if (res.statusCode !== 200) {
328             done(new Error(res.statusCode + ' status code downloading checksum'))
329             return
330           }
331
332           var chunks = []
333           res.on('data', function (chunk) {
334             chunks.push(chunk)
335           })
336           res.on('end', function () {
337             var lines = Buffer.concat(chunks).toString().trim().split('\n')
338             lines.forEach(function (line) {
339               var items = line.trim().split(/\s+/)
340               if (items.length !== 2) return
341
342               // 0035d18e2dcf9aad669b1c7c07319e17abfe3762  ./node-v0.11.4.tar.gz
343               var name = items[1].replace(/^\.\//, '')
344               expectShasums[name] = items[0]
345             })
346
347             log.verbose('checksum data', JSON.stringify(expectShasums))
348             done()
349           })
350         })
351       }
352
353       function downloadNodeLib (done) {
354         log.verbose('on Windows; need to download `iojs.lib`...')
355         var dir32 = path.resolve(devDir, 'ia32')
356           , dir64 = path.resolve(devDir, 'x64')
357           , nodeLibPath32 = path.resolve(dir32, 'iojs.lib')
358           , nodeLibPath64 = path.resolve(dir64, 'iojs.lib')
359           , nodeLibUrl32 = distUrl + '/v' + version + '/win-x86/iojs.lib'
360           , nodeLibUrl64 = distUrl + '/v' + version + '/win-x64/iojs.lib'
361
362         log.verbose('32-bit iojs.lib dir', dir32)
363         log.verbose('64-bit iojs.lib dir', dir64)
364         log.verbose('`iojs.lib` 32-bit url', nodeLibUrl32)
365         log.verbose('`iojs.lib` 64-bit url', nodeLibUrl64)
366
367         var async = 2
368         mkdir(dir32, function (err) {
369           if (err) return done(err)
370           log.verbose('streaming 32-bit iojs.lib to:', nodeLibPath32)
371
372           var req = download(nodeLibUrl32)
373           if (!req) return
374           req.on('error', done)
375           req.on('response', function (res) {
376             if (res.statusCode !== 200) {
377               done(new Error(res.statusCode + ' status code downloading 32-bit iojs.lib'))
378               return
379             }
380
381             getContentSha(res, function (_, checksum) {
382               contentShasums['win-x86/iojs.lib'] = checksum
383               log.verbose('content checksum', 'win-x86/iojs.lib', checksum)
384             })
385
386             var ws = fs.createWriteStream(nodeLibPath32)
387             ws.on('error', cb)
388             req.pipe(ws)
389           })
390           req.on('end', function () {
391             --async || done()
392           })
393         })
394         mkdir(dir64, function (err) {
395           if (err) return done(err)
396           log.verbose('streaming 64-bit iojs.lib to:', nodeLibPath64)
397
398           var req = download(nodeLibUrl64)
399           if (!req) return
400           req.on('error', done)
401           req.on('response', function (res) {
402             if (res.statusCode !== 200) {
403               done(new Error(res.statusCode + ' status code downloading 64-bit iojs.lib'))
404               return
405             }
406
407             getContentSha(res, function (_, checksum) {
408               contentShasums['win-x64/iojs.lib'] = checksum
409               log.verbose('content checksum', 'win-x64/iojs.lib', checksum)
410             })
411
412             var ws = fs.createWriteStream(nodeLibPath64)
413             ws.on('error', cb)
414             req.pipe(ws)
415           })
416           req.on('end', function () {
417             --async || done()
418           })
419         })
420       } // downloadNodeLib()
421
422     }) // mkdir()
423
424   } // go()
425
426   /**
427    * Checks if a given filename is "valid" for this installation.
428    */
429
430   function valid (file) {
431     // header files
432     return minimatch(file, '*.h', { matchBase: true }) ||
433            minimatch(file, '*.gypi', { matchBase: true })
434   }
435
436   /**
437    * The EACCES fallback is a workaround for npm's `sudo` behavior, where
438    * it drops the permissions before invoking any child processes (like
439    * node-gyp). So what happens is the "nobody" user doesn't have
440    * permission to create the dev dir. As a fallback, make the tmpdir() be
441    * the dev dir for this installation. This is not ideal, but at least
442    * the compilation will succeed...
443    */
444
445   function eaccesFallback () {
446     var tmpdir = osenv.tmpdir()
447     gyp.devDir = path.resolve(tmpdir, '.node-gyp')
448     log.warn('EACCES', 'user "%s" does not have permission to access the dev dir "%s"', osenv.user(), devDir)
449     log.warn('EACCES', 'attempting to reinstall using temporary dev dir "%s"', gyp.devDir)
450     if (process.cwd() == tmpdir) {
451       log.verbose('tmpdir == cwd', 'automatically will remove dev files after to save disk space')
452       gyp.todo.push({ name: 'remove', args: argv })
453     }
454     gyp.commands.install(argv, cb)
455   }
456
457 }