X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=org.simantics.maps.server%2Fnode%2Fnode-v4.8.0-win-x64%2Fnode_modules%2Fnpm%2Fnode_modules%2Fnode-gyp%2Flib%2Finstall.js;fp=org.simantics.maps.server%2Fnode%2Fnode-v4.8.0-win-x64%2Fnode_modules%2Fnpm%2Fnode_modules%2Fnode-gyp%2Flib%2Finstall.js;h=fa2e1c5430086ba5762e826352a594bfd2b9546e;hb=2529be6d456deeb07c128603ce4971f1dc29b695;hp=0000000000000000000000000000000000000000;hpb=2636fc31c16c23711cf2b06a4ae8537bba9c1d35;p=simantics%2Fdistrict.git

diff --git a/org.simantics.maps.server/node/node-v4.8.0-win-x64/node_modules/npm/node_modules/node-gyp/lib/install.js b/org.simantics.maps.server/node/node-v4.8.0-win-x64/node_modules/npm/node_modules/node-gyp/lib/install.js
new file mode 100644
index 00000000..fa2e1c54
--- /dev/null
+++ b/org.simantics.maps.server/node/node-v4.8.0-win-x64/node_modules/npm/node_modules/node-gyp/lib/install.js
@@ -0,0 +1,469 @@
+
+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)
+}