230 lines
7 KiB
JavaScript
230 lines
7 KiB
JavaScript
'use strict';
|
|
|
|
module.exports = exports = install;
|
|
|
|
exports.usage = 'Attempts to install pre-built binary for module';
|
|
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const log = require('npmlog');
|
|
const existsAsync = fs.exists || path.exists;
|
|
const versioning = require('./util/versioning.js');
|
|
const napi = require('./util/napi.js');
|
|
const makeDir = require('make-dir');
|
|
// for fetching binaries
|
|
const fetch = require('node-fetch');
|
|
const tar = require('tar');
|
|
|
|
let npgVersion = 'unknown';
|
|
try {
|
|
// Read own package.json to get the current node-pre-pyp version.
|
|
const ownPackageJSON = fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8');
|
|
npgVersion = JSON.parse(ownPackageJSON).version;
|
|
} catch (e) {}
|
|
|
|
function place_binary(uri, targetDir, opts, callback) {
|
|
log.http('GET', uri);
|
|
|
|
// Try getting version info from the currently running npm.
|
|
const envVersionInfo = process.env.npm_config_user_agent || `node ${process.version}`;
|
|
|
|
const sanitized = uri.replace('+', '%2B');
|
|
const requestOpts = {
|
|
uri: sanitized,
|
|
headers: {
|
|
'User-Agent': `node-pre-gyp (v${npgVersion}, ${envVersionInfo})`,
|
|
},
|
|
follow_max: 10,
|
|
};
|
|
|
|
if (opts.cafile) {
|
|
try {
|
|
requestOpts.ca = fs.readFileSync(opts.cafile);
|
|
} catch (e) {
|
|
return callback(e);
|
|
}
|
|
} else if (opts.ca) {
|
|
requestOpts.ca = opts.ca;
|
|
}
|
|
|
|
const proxyUrl = opts.proxy || process.env.http_proxy || process.env.HTTP_PROXY || process.env.npm_config_proxy;
|
|
let agent;
|
|
if (proxyUrl) {
|
|
const ProxyAgent = require('https-proxy-agent');
|
|
agent = new ProxyAgent(proxyUrl);
|
|
log.http('download', 'proxy agent configured using: "%s"', proxyUrl);
|
|
}
|
|
|
|
fetch(sanitized, { agent })
|
|
.then((res) => {
|
|
if (!res.ok) {
|
|
throw new Error(`response status ${res.status} ${res.statusText} on ${sanitized}`);
|
|
}
|
|
const dataStream = res.body;
|
|
|
|
return new Promise((resolve, reject) => {
|
|
let extractions = 0;
|
|
const countExtractions = (entry) => {
|
|
extractions += 1;
|
|
log.info('install', 'unpacking %s', entry.path);
|
|
};
|
|
|
|
dataStream.pipe(extract(targetDir, countExtractions)).on('error', (e) => {
|
|
reject(e);
|
|
});
|
|
dataStream.on('end', () => {
|
|
resolve(`extracted file count: ${extractions}`);
|
|
});
|
|
dataStream.on('error', (e) => {
|
|
reject(e);
|
|
});
|
|
});
|
|
})
|
|
.then((text) => {
|
|
log.info(text);
|
|
callback();
|
|
})
|
|
.catch((e) => {
|
|
log.error(`install ${e.message}`);
|
|
callback(e);
|
|
});
|
|
}
|
|
|
|
function extract(to, onentry) {
|
|
return tar.extract({
|
|
cwd: to,
|
|
strip: 1,
|
|
onentry,
|
|
});
|
|
}
|
|
|
|
function extract_from_local(from, targetDir, callback) {
|
|
if (!fs.existsSync(from)) {
|
|
return callback(new Error(`Cannot find file ${from}`));
|
|
}
|
|
log.info(`Found local file to extract from ${from}`);
|
|
|
|
// extract helpers
|
|
let extractCount = 0;
|
|
function countExtractions(entry) {
|
|
extractCount += 1;
|
|
log.info('install', `unpacking ${entry.path}`);
|
|
}
|
|
function afterExtract(err) {
|
|
if (err) return callback(err);
|
|
if (extractCount === 0) {
|
|
return callback(new Error('There was a fatal problem while extracting the tarball'));
|
|
}
|
|
log.info('tarball', 'done parsing tarball');
|
|
callback();
|
|
}
|
|
|
|
fs.createReadStream(from)
|
|
.pipe(extract(targetDir, countExtractions))
|
|
.on('close', afterExtract)
|
|
.on('error', afterExtract);
|
|
}
|
|
|
|
function do_build(gyp, argv, callback) {
|
|
const args = ['rebuild'].concat(argv);
|
|
gyp.todo.push({ name: 'build', args });
|
|
process.nextTick(callback);
|
|
}
|
|
|
|
function print_fallback_error(err, opts, package_json) {
|
|
const fallback_message = ' (falling back to source compile with node-gyp)';
|
|
let full_message = '';
|
|
if (err.statusCode !== undefined) {
|
|
// If we got a network response it but failed to download
|
|
// it means remote binaries are not available, so let's try to help
|
|
// the user/developer with the info to debug why
|
|
full_message = `Pre-built binaries not found for ${package_json.name}@${package_json.version}`;
|
|
full_message += ` and ${opts.runtime}@${opts.target || process.versions.node} (${opts.node_abi} ABI, ${opts.libc})`;
|
|
full_message += fallback_message;
|
|
log.warn(`Tried to download(${err.statusCode}): ${opts.hosted_tarball}`);
|
|
log.warn(full_message);
|
|
log.http(err.message);
|
|
} else {
|
|
// If we do not have a statusCode that means an unexpected error
|
|
// happened and prevented an http response, so we output the exact error
|
|
full_message = `Pre-built binaries not installable for ${package_json.name}@${package_json.version}`;
|
|
full_message += ` and ${opts.runtime}@${opts.target || process.versions.node} (${opts.node_abi} ABI, ${opts.libc})`;
|
|
full_message += fallback_message;
|
|
log.warn(full_message);
|
|
log.warn(`Hit error ${err.message}`);
|
|
}
|
|
}
|
|
|
|
//
|
|
// install
|
|
//
|
|
function install(gyp, argv, callback) {
|
|
const { package_json } = gyp;
|
|
const napi_build_version = napi.get_napi_build_version_from_command_args(argv);
|
|
const source_build = gyp.opts['build-from-source'] || gyp.opts.build_from_source;
|
|
const update_binary = gyp.opts['update-binary'] || gyp.opts.update_binary;
|
|
const should_do_source_build = source_build === package_json.name || source_build === true || source_build === 'true';
|
|
if (should_do_source_build) {
|
|
log.info('build', 'requesting source compile');
|
|
return do_build(gyp, argv, callback);
|
|
}
|
|
const fallback_to_build = gyp.opts['fallback-to-build'] || gyp.opts.fallback_to_build;
|
|
let should_do_fallback_build =
|
|
fallback_to_build === package_json.name || fallback_to_build === true || fallback_to_build === 'true';
|
|
// but allow override from npm
|
|
if (process.env.npm_config_argv) {
|
|
const { cooked } = JSON.parse(process.env.npm_config_argv);
|
|
const match = cooked.indexOf('--fallback-to-build');
|
|
if (match > -1 && cooked.length > match && cooked[match + 1] === 'false') {
|
|
should_do_fallback_build = false;
|
|
log.info('install', 'Build fallback disabled via npm flag: --fallback-to-build=false');
|
|
}
|
|
}
|
|
let opts;
|
|
try {
|
|
opts = versioning.evaluate(package_json, gyp.opts, napi_build_version);
|
|
} catch (err) {
|
|
return callback(err);
|
|
}
|
|
|
|
opts.ca = gyp.opts.ca;
|
|
opts.cafile = gyp.opts.cafile;
|
|
|
|
const from = opts.hosted_tarball;
|
|
const to = opts.module_path;
|
|
const binary_module = path.join(to, `${opts.module_name}.node`);
|
|
existsAsync(binary_module, (found) => {
|
|
if (!update_binary) {
|
|
if (found) {
|
|
console.log(`[${package_json.name}] Success: "${binary_module}" already installed`);
|
|
console.log('Pass --update-binary to reinstall or --build-from-source to recompile');
|
|
return callback();
|
|
}
|
|
log.info('check', `checked for "${binary_module}" (not found)`);
|
|
}
|
|
|
|
makeDir(to)
|
|
.then(() => {
|
|
const fileName = from.startsWith('file://') && from.slice('file://'.length);
|
|
if (fileName) {
|
|
extract_from_local(fileName, to, after_place);
|
|
} else {
|
|
place_binary(from, to, opts, after_place);
|
|
}
|
|
})
|
|
.catch((err) => {
|
|
after_place(err);
|
|
});
|
|
|
|
function after_place(err) {
|
|
if (err && should_do_fallback_build) {
|
|
print_fallback_error(err, opts, package_json);
|
|
return do_build(gyp, argv, callback);
|
|
} else if (err) {
|
|
return callback(err);
|
|
}
|
|
console.log(`[${package_json.name}] Success: "${binary_module}" is installed via remote`);
|
|
return callback();
|
|
}
|
|
});
|
|
}
|