From 7f0102e2864233b789f6f916cba89a0a60375ce6 Mon Sep 17 00:00:00 2001 From: Alex Eagle Date: Tue, 10 Sep 2019 10:25:41 -0700 Subject: [PATCH] fix(builtin): linker test should run program as an action (#1113) We were accidentally using runfiles resolution to read all user inputs, because we ran as an sh_test --- .bazelrc | 17 ++ internal/js_library/js_library.bzl | 5 +- internal/linker/BUILD.bazel | 17 +- internal/linker/README.md | 5 + internal/linker/index.js | 206 ++++++++++++++++ internal/linker/link_node_modules.bzl | 9 +- internal/linker/link_node_modules.js | 156 ------------ internal/linker/link_node_modules.ts | 225 ++++++++++++++++++ internal/linker/test/BUILD.bazel | 17 +- internal/linker/test/integration/BUILD.bazel | 46 ++-- .../dynamic_linked_pkg/BUILD.bazel | 9 + .../integration/dynamic_linked_pkg/index.js | 5 + internal/linker/test/integration/golden.txt | 1 + internal/linker/test/integration/program.js | 11 +- internal/linker/test/integration/rule.bzl | 15 +- .../linker/test/integration/run_program.sh | 71 ++++++ .../{pkg_a => static_linked_pkg}/BUILD.bazel | 4 +- .../{pkg_a => static_linked_pkg}/index.js | 0 internal/linker/test/integration/test.sh | 49 ---- .../linker/test/link_node_modules.spec.js | 58 ----- .../linker/test/link_node_modules.spec.ts | 91 +++++++ packages/typescript/src/index.from_src.bzl | 35 +++ tsconfig.json | 3 +- 23 files changed, 760 insertions(+), 295 deletions(-) create mode 100644 internal/linker/index.js delete mode 100644 internal/linker/link_node_modules.js create mode 100644 internal/linker/link_node_modules.ts create mode 100644 internal/linker/test/integration/dynamic_linked_pkg/BUILD.bazel create mode 100644 internal/linker/test/integration/dynamic_linked_pkg/index.js create mode 100644 internal/linker/test/integration/golden.txt create mode 100755 internal/linker/test/integration/run_program.sh rename internal/linker/test/integration/{pkg_a => static_linked_pkg}/BUILD.bazel (72%) rename internal/linker/test/integration/{pkg_a => static_linked_pkg}/index.js (100%) delete mode 100755 internal/linker/test/integration/test.sh delete mode 100644 internal/linker/test/link_node_modules.spec.js create mode 100644 internal/linker/test/link_node_modules.spec.ts diff --git a/.bazelrc b/.bazelrc index db08eba670..c6db3fcd16 100644 --- a/.bazelrc +++ b/.bazelrc @@ -35,3 +35,20 @@ import %workspace%/third_party/github.com/bazelbuild/bazel-toolchains/bazelrc/ba # Remote instance, borrow the one used by Angular devs build:remote --remote_instance_name=projects/internal-200822/instances/default_instance build:remote --project_id=internal-200822 + +# To reproduce Windows issues where there is no runfiles symlink there +build:no-runfiles --noenable_runfiles +# workaround https://github.com/bazelbuild/bazel/issues/7994 +build:no-runfiles --spawn_strategy=standalone +# This config is probably only used while debugging +build:no-runfiles --define=VERBOSE_LOG=1 + +# Docker Sandbox Mode +# Useful for troubleshooting Remote Build Execution problems +# See https://docs.bazel.build/versions/master/remote-execution-sandbox.html#prerequisites +build:docker-sandbox --spawn_strategy=docker --strategy=Javac=docker --genrule_strategy=docker +build:docker-sandbox --define=EXECUTOR=remote +build:docker-sandbox --experimental_docker_verbose +build:docker-sandbox --experimental_enable_docker_sandbox +# This is the same image used on BazelCI rbe_ubuntu1604 job +build:docker-sandbox --experimental_docker_image=gcr.io/cloud-marketplace/google/rbe-ubuntu16-04 diff --git a/internal/js_library/js_library.bzl b/internal/js_library/js_library.bzl index be9056ecf9..450af8adb2 100644 --- a/internal/js_library/js_library.bzl +++ b/internal/js_library/js_library.bzl @@ -48,7 +48,10 @@ def write_amd_names_shim(actions, amd_names_shim, targets): def _js_library(ctx): return [ - DefaultInfo(files = depset(ctx.files.srcs)), + DefaultInfo( + files = depset(ctx.files.srcs), + runfiles = ctx.runfiles(files = ctx.files.srcs), + ), AmdNamesInfo(names = ctx.attr.amd_names), ] diff --git a/internal/linker/BUILD.bazel b/internal/linker/BUILD.bazel index 41ca067b02..77c4aef088 100644 --- a/internal/linker/BUILD.bazel +++ b/internal/linker/BUILD.bazel @@ -1,4 +1,19 @@ -exports_files(["link_node_modules.js"]) +# BEGIN-INTERNAL +load("@npm_bazel_typescript//:index.from_src.bzl", "checked_in_ts_library") + +# We can't bootstrap the ts_library rule using the linker itself, +# because the implementation of ts_library depends on the linker so that would be a cycle. +# So we compile it to JS and check in the result as index.js +checked_in_ts_library( + name = "linker_lib", + srcs = ["link_node_modules.ts"], + checked_in_js = "index.js", + visibility = ["//internal/linker:__subpackages__"], + deps = ["@npm//@types/node"], +) + +# END-INTERNAL +exports_files(["index.js"]) filegroup( name = "package_contents", diff --git a/internal/linker/README.md b/internal/linker/README.md index 1b22c01cee..cc42422075 100644 --- a/internal/linker/README.md +++ b/internal/linker/README.md @@ -12,6 +12,11 @@ Under Bazel, we have exactly this monorepo feature. But, we want users to have a To make this seamless, we run a linker as a separate program inside the Bazel action, right before node. It does essentially the same job as Lerna: make sure there is a `$PWD/node_modules` tree and that all the semantics from Bazel (such as `module_name`/`module_root` attributes) are mapped to the node module resolution algorithm, so that the node runtime behaves the same way as if the packages had been installed from npm. +Note that the behavior of the linker depends on whether the package to link was declared as: + +1. a runtime dependency of a binary run by Bazel, which we call "statically linked", and which is resolved from Bazel's Runfiles tree or manifest +1. a dependency declared by a user of that binary, which we call "dynamically linked", and which is resolved from the execution root + In the future the linker should also generate `package.json` files so that things like `main` and `typings` fields are present and reflect the Bazel semantics, so that we can entirely eliminate custom loading and pathmapping logic from binaries we execute. [lerna]: https://github.com/lerna/lerna diff --git a/internal/linker/index.js b/internal/linker/index.js new file mode 100644 index 0000000000..c5fca5a105 --- /dev/null +++ b/internal/linker/index.js @@ -0,0 +1,206 @@ +/* THIS FILE GENERATED FROM .ts; see BUILD.bazel */ /* clang-format off */(function (factory) { + if (typeof module === "object" && typeof module.exports === "object") { + var v = factory(require, exports); + if (v !== undefined) module.exports = v; + } + else if (typeof define === "function" && define.amd) { + define("build_bazel_rules_nodejs/internal/linker/link_node_modules", ["require", "exports", "fs", "path"], factory); + } +})(function (require, exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + /** + * @fileoverview Creates a node_modules directory in the current working directory + * and symlinks in the node modules needed to run a program. + * This replaces the need for custom module resolution logic inside the process. + */ + const fs = require("fs"); + const path = require("path"); + // Run Bazel with --define=VERBOSE_LOGS=1 to enable this logging + const VERBOSE_LOGS = !!process.env['VERBOSE_LOGS']; + function log_verbose(...m) { + if (VERBOSE_LOGS) + console.error('[link_node_modules.js]', ...m); + } + function panic(m) { + throw new Error(`Internal error! Please run again with + --define=VERBOSE_LOG=1 +and file an issue: https://github.com/bazelbuild/rules_nodejs/issues/new?template=bug_report.md +Include as much of the build output as you can without disclosing anything confidential. + + Error: + ${m} + `); + } + function symlink(target, path) { + if (fs.existsSync(path)) { + // We assume here that the path is already linked to the correct target. + // Could add some logic that asserts it here, but we want to avoid an extra + // filesystem access so we should only do it under some kind of strict mode. + return; + } + log_verbose(`symlink( ${path} -> ${target} )`); + // Use junction on Windows since symlinks require elevated permissions. + // We only link to directories so junctions work for us. + fs.symlinkSync(target, path, 'junction'); + if (VERBOSE_LOGS) { + // Be verbose about creating a bad symlink + // Maybe this should fail in production as well, but again we want to avoid + // any unneeded file I/O + if (!fs.existsSync(path)) { + log_verbose('ERROR\n***\nLooks like we created a bad symlink:' + + `\n pwd ${process.cwd()}\n target ${target}\n***`); + } + } + } + /** + * Resolve a root directory string to the actual location on disk + * where node_modules was installed + * @param root a string like 'npm/node_modules' + */ + function resolveRoot(root, runfiles) { + // create a node_modules directory if no root + // this will be the case if only first-party modules are installed + if (!root) { + if (!fs.existsSync('node_modules')) { + log_verbose('no third-party packages; mkdir node_modules in ', process.cwd()); + fs.mkdirSync('node_modules'); + } + return 'node_modules'; + } + // If we got a runfilesManifest map, look through it for a resolution + // This will happen if we are running a binary that had some npm packages + // "statically linked" into its runfiles + const fromManifest = runfiles.lookupDirectory(root); + if (fromManifest) + return fromManifest; + // Account for Bazel --legacy_external_runfiles + // which look like 'my_wksp/external/npm/node_modules' + if (fs.existsSync(path.join('external', root))) { + log_verbose('Found legacy_external_runfiles, switching root to', path.join('external', root)); + return path.join('external', root); + } + // The repository should be layed out in the parent directory + // since bazel sets our working directory to the repository where the build is happening + return path.join('..', root); + } + class Runfiles { + constructor() { + // If Bazel sets a variable pointing to a runfiles manifest, + // we'll always use it. + // Note that this has a slight performance implication on Mac/Linux + // where we could use the runfiles tree already laid out on disk + // but this just costs one file read for the external npm/node_modules + // and one for each first-party module, not one per file. + if (!!process.env['RUNFILES_MANIFEST_FILE']) { + this.manifest = this.loadRunfilesManifest(process.env['RUNFILES_MANIFEST_FILE']); + } + else if (!!process.env['RUNFILES_DIR']) { + this.dir = path.resolve(process.env['RUNFILES_DIR']); + } + else { + panic('Every node program run under Bazel must have a $RUNFILES_DIR or $RUNFILES_MANIFEST_FILE environment variable'); + } + // Under --noenable_runfiles (in particular on Windows) + // Bazel sets RUNFILES_MANIFEST_ONLY=1. + // When this happens, we need to read the manifest file to locate + // inputs + if (process.env['RUNFILES_MANIFEST_ONLY'] === '1' && !process.env['RUNFILES_MANIFEST_FILE']) { + log_verbose(`Workaround https://github.com/bazelbuild/bazel/issues/7994 + RUNFILES_MANIFEST_FILE should have been set but wasn't. + falling back to using runfiles symlinks. + If you want to test runfiles manifest behavior, add + --spawn_strategy=standalone to the command line.`); + } + } + lookupDirectory(dir) { + if (!this.manifest) + return undefined; + for (const [k, v] of this.manifest) { + // Entry looks like + // k: npm/node_modules/semver/LICENSE + // v: /path/to/external/npm/node_modules/semver/LICENSE + // calculate l = length(`/semver/LICENSE`) + if (k.startsWith(dir)) { + const l = k.length - dir.length; + return v.substring(0, v.length - l); + } + } + } + /** + * The runfiles manifest maps from short_path + * https://docs.bazel.build/versions/master/skylark/lib/File.html#short_path + * to the actual location on disk where the file can be read. + * + * In a sandboxed execution, it does not exist. In that case, runfiles must be + * resolved from a symlink tree under the runfiles dir. + * See https://github.com/bazelbuild/bazel/issues/3726 + */ + loadRunfilesManifest(manifestPath) { + log_verbose(`using runfiles manifest ${manifestPath}`); + const runfilesEntries = new Map(); + const input = fs.readFileSync(manifestPath, { encoding: 'utf-8' }); + for (const line of input.split('\n')) { + if (!line) + continue; + const [runfilesPath, realPath] = line.split(' '); + runfilesEntries.set(runfilesPath, realPath); + } + return runfilesEntries; + } + } + exports.Runfiles = Runfiles; + function main(args, runfiles) { + if (!args || args.length < 1) + throw new Error('link_node_modules.js requires one argument: modulesManifest path'); + const [modulesManifest] = args; + let { root, modules, workspace } = JSON.parse(fs.readFileSync(modulesManifest)); + modules = modules || {}; + log_verbose(`module manifest: workspace ${workspace}, root ${root} with first-party packages\n`, modules); + const rootDir = resolveRoot(root, runfiles); + log_verbose('resolved root', root, 'to', rootDir); + // Bazel starts actions with pwd=execroot/my_wksp + const workspaceDir = path.resolve('.'); + // Convert from runfiles path + // this_wksp/path/to/file OR other_wksp/path/to/file + // to execroot path + // path/to/file OR external/other_wksp/path/to/file + function toWorkspaceDir(p) { + if (p.startsWith(workspace + path.sep)) { + return p.substring(workspace.length + 1); + } + return path.join('external', p); + } + // Create the $pwd/node_modules directory that node will resolve from + symlink(rootDir, 'node_modules'); + process.chdir(rootDir); + // Symlinks to packages need to reach back to the workspace/runfiles directory + const workspaceRelative = path.relative('.', workspaceDir); + const runfilesRelative = runfiles.dir ? path.relative('.', runfiles.dir) : undefined; + // Now add symlinks to each of our first-party packages so they appear under the node_modules tree + for (const m of Object.keys(modules)) { + let target; + // Look in the runfiles first + // TODO: this could be a method in the Runfiles class + if (runfiles.manifest) { + target = runfiles.lookupDirectory(modules[m]); + } + else if (runfilesRelative) { + target = path.join(runfilesRelative, modules[m]); + } + // It sucks that we have to do a FS call here. + // TODO: could we know which packages are statically linked?? + if (!target || !fs.existsSync(target)) { + // Try the execroot + target = path.join(workspaceRelative, toWorkspaceDir(modules[m])); + } + symlink(target, m); + } + return 0; + } + exports.main = main; + if (require.main === module) { + process.exitCode = main(process.argv.slice(2), new Runfiles()); + } +}); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"link_node_modules.js","sourceRoot":"","sources":["../../../../../internal/linker/link_node_modules.ts"],"names":[],"mappings":";;;;;;;;;;;IAAA;;;;OAIG;IACH,yBAAyB;IACzB,6BAA6B;IAE7B,gEAAgE;IAChE,MAAM,YAAY,GAAG,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IAEnD,SAAS,WAAW,CAAC,GAAG,CAAW;QACjC,IAAI,YAAY;YAAE,OAAO,CAAC,KAAK,CAAC,wBAAwB,EAAE,GAAG,CAAC,CAAC,CAAC;IAClE,CAAC;IAED,SAAS,KAAK,CAAC,CAAS;QACtB,MAAM,IAAI,KAAK,CAAC;;;;;;IAMd,CAAC;GACF,CAAC,CAAC;IACL,CAAC;IAED,SAAS,OAAO,CAAC,MAAc,EAAE,IAAY;QAC3C,IAAI,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;YACvB,wEAAwE;YACxE,2EAA2E;YAC3E,4EAA4E;YAC5E,OAAO;SACR;QACD,WAAW,CAAC,YAAY,IAAI,OAAO,MAAM,IAAI,CAAC,CAAC;QAC/C,uEAAuE;QACvE,wDAAwD;QACxD,EAAE,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;QACzC,IAAI,YAAY,EAAE;YAChB,0CAA0C;YAC1C,2EAA2E;YAC3E,wBAAwB;YACxB,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;gBACxB,WAAW,CACP,kDAAkD;oBAClD,WAAW,OAAO,CAAC,GAAG,EAAE,cAAc,MAAM,OAAO,CAAC,CAAC;aAC1D;SACF;IACH,CAAC;IAED;;;;OAIG;IACH,SAAS,WAAW,CAAC,IAAsB,EAAE,QAAkB;QAC7D,6CAA6C;QAC7C,kEAAkE;QAClE,IAAI,CAAC,IAAI,EAAE;YACT,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE;gBAClC,WAAW,CAAC,iDAAiD,EAAE,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;gBAC9E,EAAE,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;aAC9B;YACD,OAAO,cAAc,CAAC;SACvB;QAED,qEAAqE;QACrE,yEAAyE;QACzE,wCAAwC;QACxC,MAAM,YAAY,GAAG,QAAQ,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QACpD,IAAI,YAAY;YAAE,OAAO,YAAY,CAAC;QAEtC,+CAA+C;QAC/C,sDAAsD;QACtD,IAAI,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,EAAE;YAC9C,WAAW,CAAC,mDAAmD,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC;YAC9F,OAAO,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;SACpC;QAED,6DAA6D;QAC7D,wFAAwF;QACxF,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC/B,CAAC;IAED,MAAa,QAAQ;QAInB;YACE,4DAA4D;YAC5D,uBAAuB;YACvB,mEAAmE;YACnE,gEAAgE;YAChE,sEAAsE;YACtE,yDAAyD;YACzD,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,EAAE;gBAC3C,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAE,CAAC,CAAC;aACnF;iBAAM,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,EAAE;gBACxC,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAE,CAAC,CAAC;aACvD;iBAAM;gBACL,KAAK,CACD,8GAA8G,CAAC,CAAC;aACrH;YACD,uDAAuD;YACvD,uCAAuC;YACvC,iEAAiE;YACjE,SAAS;YACT,IAAI,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,EAAE;gBAC3F,WAAW,CAAC;;;;kEAIgD,CAAC,CAAC;aAC/D;QACH,CAAC;QAED,eAAe,CAAC,GAAW;YACzB,IAAI,CAAC,IAAI,CAAC,QAAQ;gBAAE,OAAO,SAAS,CAAC;YAErC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,QAAQ,EAAE;gBAClC,mBAAmB;gBACnB,qCAAqC;gBACrC,uDAAuD;gBACvD,0CAA0C;gBAC1C,IAAI,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;oBACrB,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC;oBAChC,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;iBACrC;aACF;QACH,CAAC;QAGD;;;;;;;;WAQG;QACH,oBAAoB,CAAC,YAAoB;YACvC,WAAW,CAAC,2BAA2B,YAAY,EAAE,CAAC,CAAC;YAEvD,MAAM,eAAe,GAAG,IAAI,GAAG,EAAE,CAAC;YAClC,MAAM,KAAK,GAAG,EAAE,CAAC,YAAY,CAAC,YAAY,EAAE,EAAC,QAAQ,EAAE,OAAO,EAAC,CAAC,CAAC;YAEjE,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;gBACpC,IAAI,CAAC,IAAI;oBAAE,SAAS;gBACpB,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBACjD,eAAe,CAAC,GAAG,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;aAC7C;YAED,OAAO,eAAe,CAAC;QACzB,CAAC;KACF;IAvED,4BAuEC;IASD,SAAgB,IAAI,CAAC,IAAc,EAAE,QAAkB;QACrD,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,kEAAkE,CAAC,CAAC;QAEtF,MAAM,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC;QAC/B,IAAI,EAAC,IAAI,EAAE,OAAO,EAAE,SAAS,EAAC,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC,CAAC;QAC9E,OAAO,GAAG,OAAO,IAAI,EAAE,CAAC;QACxB,WAAW,CACP,8BAA8B,SAAS,UAAU,IAAI,8BAA8B,EAAE,OAAO,CAAC,CAAC;QAElG,MAAM,OAAO,GAAG,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QAC5C,WAAW,CAAC,eAAe,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;QAElD,iDAAiD;QACjD,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAEvC,6BAA6B;QAC7B,oDAAoD;QACpD,mBAAmB;QACnB,mDAAmD;QACnD,SAAS,cAAc,CAAC,CAAS;YAC/B,IAAI,CAAC,CAAC,UAAU,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE;gBACtC,OAAO,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;aAC1C;YACD,OAAO,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;QAClC,CAAC;QAED,qEAAqE;QACrE,OAAO,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;QACjC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAEvB,8EAA8E;QAC9E,MAAM,iBAAiB,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;QAC3D,MAAM,gBAAgB,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAErF,kGAAkG;QAClG,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE;YACpC,IAAI,MAAwB,CAAC;YAE7B,6BAA6B;YAC7B,qDAAqD;YACrD,IAAI,QAAQ,CAAC,QAAQ,EAAE;gBACrB,MAAM,GAAG,QAAQ,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;aAC/C;iBAAM,IAAI,gBAAgB,EAAE;gBAC3B,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;aAClD;YAED,8CAA8C;YAC9C,6DAA6D;YAC7D,IAAI,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;gBACrC,mBAAmB;gBACnB,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;aACnE;YACD,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;SACpB;QAED,OAAO,CAAC,CAAC;IACX,CAAC;IAzDD,oBAyDC;IAED,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,EAAE;QAC3B,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,QAAQ,EAAE,CAAC,CAAC;KAChE","sourcesContent":["/**\n * @fileoverview Creates a node_modules directory in the current working directory\n * and symlinks in the node modules needed to run a program.\n * This replaces the need for custom module resolution logic inside the process.\n */\nimport * as fs from 'fs';\nimport * as path from 'path';\n\n// Run Bazel with --define=VERBOSE_LOGS=1 to enable this logging\nconst VERBOSE_LOGS = !!process.env['VERBOSE_LOGS'];\n\nfunction log_verbose(...m: string[]) {\n  if (VERBOSE_LOGS) console.error('[link_node_modules.js]', ...m);\n}\n\nfunction panic(m: string) {\n  throw new Error(`Internal error! Please run again with\n   --define=VERBOSE_LOG=1\nand file an issue: https://github.com/bazelbuild/rules_nodejs/issues/new?template=bug_report.md\nInclude as much of the build output as you can without disclosing anything confidential.\n\n  Error:\n  ${m}\n  `);\n}\n\nfunction symlink(target: string, path: string) {\n  if (fs.existsSync(path)) {\n    // We assume here that the path is already linked to the correct target.\n    // Could add some logic that asserts it here, but we want to avoid an extra\n    // filesystem access so we should only do it under some kind of strict mode.\n    return;\n  }\n  log_verbose(`symlink( ${path} -> ${target} )`);\n  // Use junction on Windows since symlinks require elevated permissions.\n  // We only link to directories so junctions work for us.\n  fs.symlinkSync(target, path, 'junction');\n  if (VERBOSE_LOGS) {\n    // Be verbose about creating a bad symlink\n    // Maybe this should fail in production as well, but again we want to avoid\n    // any unneeded file I/O\n    if (!fs.existsSync(path)) {\n      log_verbose(\n          'ERROR\\n***\\nLooks like we created a bad symlink:' +\n          `\\n  pwd ${process.cwd()}\\n  target ${target}\\n***`);\n    }\n  }\n}\n\n/**\n * Resolve a root directory string to the actual location on disk\n * where node_modules was installed\n * @param root a string like 'npm/node_modules'\n */\nfunction resolveRoot(root: string|undefined, runfiles: Runfiles) {\n  // create a node_modules directory if no root\n  // this will be the case if only first-party modules are installed\n  if (!root) {\n    if (!fs.existsSync('node_modules')) {\n      log_verbose('no third-party packages; mkdir node_modules in ', process.cwd());\n      fs.mkdirSync('node_modules');\n    }\n    return 'node_modules';\n  }\n\n  // If we got a runfilesManifest map, look through it for a resolution\n  // This will happen if we are running a binary that had some npm packages\n  // \"statically linked\" into its runfiles\n  const fromManifest = runfiles.lookupDirectory(root);\n  if (fromManifest) return fromManifest;\n\n  // Account for Bazel --legacy_external_runfiles\n  // which look like 'my_wksp/external/npm/node_modules'\n  if (fs.existsSync(path.join('external', root))) {\n    log_verbose('Found legacy_external_runfiles, switching root to', path.join('external', root));\n    return path.join('external', root);\n  }\n\n  // The repository should be layed out in the parent directory\n  // since bazel sets our working directory to the repository where the build is happening\n  return path.join('..', root);\n}\n\nexport class Runfiles {\n  manifest: Map<string, string>|undefined;\n  dir: string|undefined;\n\n  constructor() {\n    // If Bazel sets a variable pointing to a runfiles manifest,\n    // we'll always use it.\n    // Note that this has a slight performance implication on Mac/Linux\n    // where we could use the runfiles tree already laid out on disk\n    // but this just costs one file read for the external npm/node_modules\n    // and one for each first-party module, not one per file.\n    if (!!process.env['RUNFILES_MANIFEST_FILE']) {\n      this.manifest = this.loadRunfilesManifest(process.env['RUNFILES_MANIFEST_FILE']!);\n    } else if (!!process.env['RUNFILES_DIR']) {\n      this.dir = path.resolve(process.env['RUNFILES_DIR']!);\n    } else {\n      panic(\n          'Every node program run under Bazel must have a $RUNFILES_DIR or $RUNFILES_MANIFEST_FILE environment variable');\n    }\n    // Under --noenable_runfiles (in particular on Windows)\n    // Bazel sets RUNFILES_MANIFEST_ONLY=1.\n    // When this happens, we need to read the manifest file to locate\n    // inputs\n    if (process.env['RUNFILES_MANIFEST_ONLY'] === '1' && !process.env['RUNFILES_MANIFEST_FILE']) {\n      log_verbose(`Workaround https://github.com/bazelbuild/bazel/issues/7994\n                 RUNFILES_MANIFEST_FILE should have been set but wasn't.\n                 falling back to using runfiles symlinks.\n                 If you want to test runfiles manifest behavior, add\n                 --spawn_strategy=standalone to the command line.`);\n    }\n  }\n\n  lookupDirectory(dir: string): string|undefined {\n    if (!this.manifest) return undefined;\n\n    for (const [k, v] of this.manifest) {\n      // Entry looks like\n      // k: npm/node_modules/semver/LICENSE\n      // v: /path/to/external/npm/node_modules/semver/LICENSE\n      // calculate l = length(`/semver/LICENSE`)\n      if (k.startsWith(dir)) {\n        const l = k.length - dir.length;\n        return v.substring(0, v.length - l);\n      }\n    }\n  }\n\n\n  /**\n   * The runfiles manifest maps from short_path\n   * https://docs.bazel.build/versions/master/skylark/lib/File.html#short_path\n   * to the actual location on disk where the file can be read.\n   *\n   * In a sandboxed execution, it does not exist. In that case, runfiles must be\n   * resolved from a symlink tree under the runfiles dir.\n   * See https://github.com/bazelbuild/bazel/issues/3726\n   */\n  loadRunfilesManifest(manifestPath: string) {\n    log_verbose(`using runfiles manifest ${manifestPath}`);\n\n    const runfilesEntries = new Map();\n    const input = fs.readFileSync(manifestPath, {encoding: 'utf-8'});\n\n    for (const line of input.split('\\n')) {\n      if (!line) continue;\n      const [runfilesPath, realPath] = line.split(' ');\n      runfilesEntries.set(runfilesPath, realPath);\n    }\n\n    return runfilesEntries;\n  }\n}\n\n// TypeScript lib.es5.d.ts has a mistake: JSON.parse does accept Buffer.\ndeclare global {\n  interface JSON {\n    parse(b: Buffer): any;\n  }\n}\n\nexport function main(args: string[], runfiles: Runfiles) {\n  if (!args || args.length < 1)\n    throw new Error('link_node_modules.js requires one argument: modulesManifest path');\n\n  const [modulesManifest] = args;\n  let {root, modules, workspace} = JSON.parse(fs.readFileSync(modulesManifest));\n  modules = modules || {};\n  log_verbose(\n      `module manifest: workspace ${workspace}, root ${root} with first-party packages\\n`, modules);\n\n  const rootDir = resolveRoot(root, runfiles);\n  log_verbose('resolved root', root, 'to', rootDir);\n\n  // Bazel starts actions with pwd=execroot/my_wksp\n  const workspaceDir = path.resolve('.');\n\n  // Convert from runfiles path\n  // this_wksp/path/to/file OR other_wksp/path/to/file\n  // to execroot path\n  // path/to/file OR external/other_wksp/path/to/file\n  function toWorkspaceDir(p: string) {\n    if (p.startsWith(workspace + path.sep)) {\n      return p.substring(workspace.length + 1);\n    }\n    return path.join('external', p);\n  }\n\n  // Create the $pwd/node_modules directory that node will resolve from\n  symlink(rootDir, 'node_modules');\n  process.chdir(rootDir);\n\n  // Symlinks to packages need to reach back to the workspace/runfiles directory\n  const workspaceRelative = path.relative('.', workspaceDir);\n  const runfilesRelative = runfiles.dir ? path.relative('.', runfiles.dir) : undefined;\n\n  // Now add symlinks to each of our first-party packages so they appear under the node_modules tree\n  for (const m of Object.keys(modules)) {\n    let target: string|undefined;\n\n    // Look in the runfiles first\n    // TODO: this could be a method in the Runfiles class\n    if (runfiles.manifest) {\n      target = runfiles.lookupDirectory(modules[m]);\n    } else if (runfilesRelative) {\n      target = path.join(runfilesRelative, modules[m]);\n    }\n\n    // It sucks that we have to do a FS call here.\n    // TODO: could we know which packages are statically linked??\n    if (!target || !fs.existsSync(target)) {\n      // Try the execroot\n      target = path.join(workspaceRelative, toWorkspaceDir(modules[m]));\n    }\n    symlink(target, m);\n  }\n\n  return 0;\n}\n\nif (require.main === module) {\n  process.exitCode = main(process.argv.slice(2), new Runfiles());\n}\n"]} \ No newline at end of file diff --git a/internal/linker/link_node_modules.bzl b/internal/linker/link_node_modules.bzl index 7d933597ae..8277536ee6 100644 --- a/internal/linker/link_node_modules.bzl +++ b/internal/linker/link_node_modules.bzl @@ -20,7 +20,7 @@ def _debug(vars, *args): _ASPECT_RESULT_NAME = "link_node_modules__aspect_result" # Traverse 'srcs' in addition so that we can go across a genrule -_MODULE_MAPPINGS_DEPS_NAMES = ["deps", "srcs"] +_MODULE_MAPPINGS_DEPS_NAMES = ["data", "deps", "srcs"] def register_node_modules_linker(ctx, args, inputs): """Helps an action to run node by setting up the node_modules linker as a pre-process @@ -55,7 +55,12 @@ def register_node_modules_linker(ctx, args, inputs): # Write the result to a file, and use the magic node option --bazel_node_modules_manifest # The node_launcher.sh will peel off this argument and pass it to the linker rather than the program. modules_manifest = ctx.actions.declare_file("_%s.module_mappings.json" % ctx.label.name) - ctx.actions.write(modules_manifest, str({"modules": mappings, "root": node_modules_root})) + content = { + "modules": mappings, + "root": node_modules_root, + "workspace": ctx.workspace_name, + } + ctx.actions.write(modules_manifest, str(content)) args.add("--bazel_node_modules_manifest=%s" % modules_manifest.path) inputs.append(modules_manifest) diff --git a/internal/linker/link_node_modules.js b/internal/linker/link_node_modules.js deleted file mode 100644 index e37f76dd3c..0000000000 --- a/internal/linker/link_node_modules.js +++ /dev/null @@ -1,156 +0,0 @@ -/** - * @fileoverview Creates a node_modules directory in the current working directory - * and symlinks in the node modules needed to run a program. - * This replaces the need for custom module resolution logic inside the process. - */ -const fs = require('fs'); -const path = require('path'); - -const VERBOSE_LOGS = !!process.env['VERBOSE_LOGS']; - -function log_verbose(...m) { - // This is a template file so we use __filename to output the actual filename - if (VERBOSE_LOGS) console.error('[link_node_modules.js]', ...m); -} - -function symlink(target, path) { - if (fs.existsSync(path)) { - // We assume here that the path is already linked to the correct target. - // Could add some logic that asserts it here, but we want to avoid an extra - // filesystem access so we should only do it under some kind of strict mode. - return; - } - log_verbose(`symlink( ${path} -> ${target} )`); - // Use junction on Windows since symlinks require elevated permissions - // we only link to directories so junctions work for us. - fs.symlinkSync(target, path, 'junction'); -} - -/** - * The runfiles manifest maps from short_path - * https://docs.bazel.build/versions/master/skylark/lib/File.html#short_path - * to the actual location on disk where the file can be read. - * - * In a sandboxed execution, it does not exist. In that case, runfiles must be - * resolved from a symlink tree under the runfiles dir. - * See https://github.com/bazelbuild/bazel/issues/3726 - */ -function loadRunfilesManifest(manifestPath) { - log_verbose(`using runfiles manifest ${manifestPath}`); - - // Create the manifest and reverse manifest maps. - const runfilesEntries = new Map(); - const input = fs.readFileSync(manifestPath, {encoding: 'utf-8'}); - - for (const line of input.split('\n')) { - if (!line) continue; - const [runfilesPath, realPath] = line.split(' '); - runfilesEntries.set(runfilesPath, realPath); - } - - return runfilesEntries; -} - -function lookupDirectory(dir, runfilesManifest) { - for (const [k, v] of runfilesManifest) { - // Entry looks like - // k: npm/node_modules/semver/LICENSE - // v: /path/to/external/npm/node_modules/semver/LICENSE - // calculate l = length(`/semver/LICENSE`) - if (k.startsWith(dir)) { - const l = k.length - dir.length; - return v.substring(0, v.length - l); - } - } - throw new Error(`Internal failure, please report an issue. - RunfilesManifest has no key for ${dir} - `); -} - -/** - * Resolve a root directory string to the actual location on disk - * where node_modules was installed - * @param root a string like 'npm/node_modules' - */ -function resolveRoot(root, runfilesManifest) { - // create a node_modules directory if no root - // this will be the case if only first-party modules are installed - if (!root) { - log_verbose('no third-party packages; mkdir node_modules in ', process.cwd); - fs.mkdirSync('node_modules'); - return 'node_modules'; - } - - // If we got a runfilesManifest map, look through it for a resolution - if (runfilesManifest) { - return lookupDirectory(root, runfilesManifest); - } - - // Account for Bazel --legacy_external_runfiles - // which look like 'my_wksp/external/npm/node_modules' - if (fs.existsSync(path.join('external', root))) { - log_verbose('Found legacy_external_runfiles, switching root to', path.join('external', root)); - return path.join('external', root); - } - - // The repository should be layed out in the parent directory - // since bazel sets our working directory to the repository where the build is happening - return path.join('..', root); -} - -function main(args, runfilesManifestPath) { - if (!args || args.length < 1) - throw new Error('link_node_modules.js requires one argument: modulesManifest path'); - - const [modulesManifest] = args; - let {root, modules} = JSON.parse(fs.readFileSync(modulesManifest)); - modules = modules || {}; - log_verbose( - 'read module manifest, node_modules root is', root, 'with first-party packages', modules); - - const runfilesManifest = - runfilesManifestPath ? loadRunfilesManifest(runfilesManifestPath) : undefined; - const rootDir = resolveRoot(root, runfilesManifest); - log_verbose('resolved root', root, 'to', rootDir); - - // Create the execroot/my_wksp/node_modules directory that node will resolve from - symlink(rootDir, 'node_modules'); - - // Typically, cwd=foo, root=external/npm/node_modules, so we want links to be - // ../../../../foo/path/to/package - const symlinkRelativeTarget = path.relative(rootDir, '..'); - process.chdir(rootDir); - - // Now add symlinks to each of our first-party packages so they appear under the node_modules tree - for (const m of Object.keys(modules)) { - const target = runfilesManifest ? lookupDirectory(modules[m], runfilesManifest) : - path.join(symlinkRelativeTarget, modules[m]); - symlink(target, m); - } - - return 0; -} - -exports.main = main; - -if (require.main === module) { - // If Bazel sets a variable pointing to a runfiles manifest, - // we'll always use it. - // Note that this has a slight performance implication on Mac/Linux - // where we could use the runfiles tree already laid out on disk - // but this just costs one file read for the external npm/node_modules - // and one for each first-party module, not one per file. - const runfilesManifestPath = process.env['RUNFILES_MANIFEST_FILE']; - // Under --noenable_runfiles (in particular on Windows) - // Bazel sets RUNFILES_MANIFEST_ONLY=1. - // When this happens, we need to read the manifest file to locate - // inputs - if (process.env['RUNFILES_MANIFEST_ONLY'] === '1' && !runfilesManifestPath) { - log_verbose(`Workaround https://github.com/bazelbuild/bazel/issues/7994 - RUNFILES_MANIFEST_FILE should have been set but wasn't. - falling back to using runfiles symlinks. - If you want to test runfiles manifest behavior, add - --spawn_strategy=standalone to the command line.`); - } - process.exitCode = main(process.argv.slice(2), runfilesManifestPath); -} \ No newline at end of file diff --git a/internal/linker/link_node_modules.ts b/internal/linker/link_node_modules.ts new file mode 100644 index 0000000000..67c2b37e12 --- /dev/null +++ b/internal/linker/link_node_modules.ts @@ -0,0 +1,225 @@ +/** + * @fileoverview Creates a node_modules directory in the current working directory + * and symlinks in the node modules needed to run a program. + * This replaces the need for custom module resolution logic inside the process. + */ +import * as fs from 'fs'; +import * as path from 'path'; + +// Run Bazel with --define=VERBOSE_LOGS=1 to enable this logging +const VERBOSE_LOGS = !!process.env['VERBOSE_LOGS']; + +function log_verbose(...m: string[]) { + if (VERBOSE_LOGS) console.error('[link_node_modules.js]', ...m); +} + +function panic(m: string) { + throw new Error(`Internal error! Please run again with + --define=VERBOSE_LOG=1 +and file an issue: https://github.com/bazelbuild/rules_nodejs/issues/new?template=bug_report.md +Include as much of the build output as you can without disclosing anything confidential. + + Error: + ${m} + `); +} + +function symlink(target: string, path: string) { + if (fs.existsSync(path)) { + // We assume here that the path is already linked to the correct target. + // Could add some logic that asserts it here, but we want to avoid an extra + // filesystem access so we should only do it under some kind of strict mode. + return; + } + log_verbose(`symlink( ${path} -> ${target} )`); + // Use junction on Windows since symlinks require elevated permissions. + // We only link to directories so junctions work for us. + fs.symlinkSync(target, path, 'junction'); + if (VERBOSE_LOGS) { + // Be verbose about creating a bad symlink + // Maybe this should fail in production as well, but again we want to avoid + // any unneeded file I/O + if (!fs.existsSync(path)) { + log_verbose( + 'ERROR\n***\nLooks like we created a bad symlink:' + + `\n pwd ${process.cwd()}\n target ${target}\n***`); + } + } +} + +/** + * Resolve a root directory string to the actual location on disk + * where node_modules was installed + * @param root a string like 'npm/node_modules' + */ +function resolveRoot(root: string|undefined, runfiles: Runfiles) { + // create a node_modules directory if no root + // this will be the case if only first-party modules are installed + if (!root) { + if (!fs.existsSync('node_modules')) { + log_verbose('no third-party packages; mkdir node_modules in ', process.cwd()); + fs.mkdirSync('node_modules'); + } + return 'node_modules'; + } + + // If we got a runfilesManifest map, look through it for a resolution + // This will happen if we are running a binary that had some npm packages + // "statically linked" into its runfiles + const fromManifest = runfiles.lookupDirectory(root); + if (fromManifest) return fromManifest; + + // Account for Bazel --legacy_external_runfiles + // which look like 'my_wksp/external/npm/node_modules' + if (fs.existsSync(path.join('external', root))) { + log_verbose('Found legacy_external_runfiles, switching root to', path.join('external', root)); + return path.join('external', root); + } + + // The repository should be layed out in the parent directory + // since bazel sets our working directory to the repository where the build is happening + return path.join('..', root); +} + +export class Runfiles { + manifest: Map|undefined; + dir: string|undefined; + + constructor() { + // If Bazel sets a variable pointing to a runfiles manifest, + // we'll always use it. + // Note that this has a slight performance implication on Mac/Linux + // where we could use the runfiles tree already laid out on disk + // but this just costs one file read for the external npm/node_modules + // and one for each first-party module, not one per file. + if (!!process.env['RUNFILES_MANIFEST_FILE']) { + this.manifest = this.loadRunfilesManifest(process.env['RUNFILES_MANIFEST_FILE']!); + } else if (!!process.env['RUNFILES_DIR']) { + this.dir = path.resolve(process.env['RUNFILES_DIR']!); + } else { + panic( + 'Every node program run under Bazel must have a $RUNFILES_DIR or $RUNFILES_MANIFEST_FILE environment variable'); + } + // Under --noenable_runfiles (in particular on Windows) + // Bazel sets RUNFILES_MANIFEST_ONLY=1. + // When this happens, we need to read the manifest file to locate + // inputs + if (process.env['RUNFILES_MANIFEST_ONLY'] === '1' && !process.env['RUNFILES_MANIFEST_FILE']) { + log_verbose(`Workaround https://github.com/bazelbuild/bazel/issues/7994 + RUNFILES_MANIFEST_FILE should have been set but wasn't. + falling back to using runfiles symlinks. + If you want to test runfiles manifest behavior, add + --spawn_strategy=standalone to the command line.`); + } + } + + lookupDirectory(dir: string): string|undefined { + if (!this.manifest) return undefined; + + for (const [k, v] of this.manifest) { + // Entry looks like + // k: npm/node_modules/semver/LICENSE + // v: /path/to/external/npm/node_modules/semver/LICENSE + // calculate l = length(`/semver/LICENSE`) + if (k.startsWith(dir)) { + const l = k.length - dir.length; + return v.substring(0, v.length - l); + } + } + } + + + /** + * The runfiles manifest maps from short_path + * https://docs.bazel.build/versions/master/skylark/lib/File.html#short_path + * to the actual location on disk where the file can be read. + * + * In a sandboxed execution, it does not exist. In that case, runfiles must be + * resolved from a symlink tree under the runfiles dir. + * See https://github.com/bazelbuild/bazel/issues/3726 + */ + loadRunfilesManifest(manifestPath: string) { + log_verbose(`using runfiles manifest ${manifestPath}`); + + const runfilesEntries = new Map(); + const input = fs.readFileSync(manifestPath, {encoding: 'utf-8'}); + + for (const line of input.split('\n')) { + if (!line) continue; + const [runfilesPath, realPath] = line.split(' '); + runfilesEntries.set(runfilesPath, realPath); + } + + return runfilesEntries; + } +} + +// TypeScript lib.es5.d.ts has a mistake: JSON.parse does accept Buffer. +declare global { + interface JSON { + parse(b: Buffer): any; + } +} + +export function main(args: string[], runfiles: Runfiles) { + if (!args || args.length < 1) + throw new Error('link_node_modules.js requires one argument: modulesManifest path'); + + const [modulesManifest] = args; + let {root, modules, workspace} = JSON.parse(fs.readFileSync(modulesManifest)); + modules = modules || {}; + log_verbose( + `module manifest: workspace ${workspace}, root ${root} with first-party packages\n`, modules); + + const rootDir = resolveRoot(root, runfiles); + log_verbose('resolved root', root, 'to', rootDir); + + // Bazel starts actions with pwd=execroot/my_wksp + const workspaceDir = path.resolve('.'); + + // Convert from runfiles path + // this_wksp/path/to/file OR other_wksp/path/to/file + // to execroot path + // path/to/file OR external/other_wksp/path/to/file + function toWorkspaceDir(p: string) { + if (p.startsWith(workspace + path.sep)) { + return p.substring(workspace.length + 1); + } + return path.join('external', p); + } + + // Create the $pwd/node_modules directory that node will resolve from + symlink(rootDir, 'node_modules'); + process.chdir(rootDir); + + // Symlinks to packages need to reach back to the workspace/runfiles directory + const workspaceRelative = path.relative('.', workspaceDir); + const runfilesRelative = runfiles.dir ? path.relative('.', runfiles.dir) : undefined; + + // Now add symlinks to each of our first-party packages so they appear under the node_modules tree + for (const m of Object.keys(modules)) { + let target: string|undefined; + + // Look in the runfiles first + // TODO: this could be a method in the Runfiles class + if (runfiles.manifest) { + target = runfiles.lookupDirectory(modules[m]); + } else if (runfilesRelative) { + target = path.join(runfilesRelative, modules[m]); + } + + // It sucks that we have to do a FS call here. + // TODO: could we know which packages are statically linked?? + if (!target || !fs.existsSync(target)) { + // Try the execroot + target = path.join(workspaceRelative, toWorkspaceDir(modules[m])); + } + symlink(target, m); + } + + return 0; +} + +if (require.main === module) { + process.exitCode = main(process.argv.slice(2), new Runfiles()); +} diff --git a/internal/linker/test/BUILD.bazel b/internal/linker/test/BUILD.bazel index cd2d294383..ca7b91fdbe 100644 --- a/internal/linker/test/BUILD.bazel +++ b/internal/linker/test/BUILD.bazel @@ -1,7 +1,20 @@ load("@npm_bazel_jasmine//:index.from_src.bzl", "jasmine_node_test") +load("@npm_bazel_typescript//:index.from_src.bzl", "ts_library") + +ts_library( + name = "test_lib", + srcs = glob(["*.ts"]), + deps = [ + "//internal/linker:linker_lib", + "@npm//@types/jasmine", + "@npm//@types/node", + ], +) jasmine_node_test( name = "unit_tests", - srcs = glob(["*.js"]), - data = ["//internal/linker:link_node_modules.js"], + srcs = ["test_lib"], + # NB: for better dev round-trip, we test against the ts_library target + # rather than update the index.js it's transpiled from. + data = ["//internal/linker:linker_lib"], ) diff --git a/internal/linker/test/integration/BUILD.bazel b/internal/linker/test/integration/BUILD.bazel index 1221fd1edc..2ce98177f5 100644 --- a/internal/linker/test/integration/BUILD.bazel +++ b/internal/linker/test/integration/BUILD.bazel @@ -1,32 +1,46 @@ +load("@build_bazel_rules_nodejs//internal/golden_file_test:golden_file_test.bzl", "golden_file_test") load(":rule.bzl", "linked") -linked( - name = "example", - deps = [ - "//internal/linker/test/integration/pkg_a", - "@npm//semver", - ], -) - # Use the node binary supplied by the bazel toolchain +# Normally the nodejs_binary rule would do this, +# but we want to have a more minimal test fixture genrule( name = "replace_node_path", - srcs = [":test.sh"], - outs = ["test_with_node.sh"], + srcs = [":run_program.sh"], + outs = ["run_program_with_node.sh"], cmd = "sed s#NODE_PATH#$(NODE_PATH)# $< > $@", toolchains = ["@build_bazel_rules_nodejs//toolchains/node:toolchain"], ) -sh_test( - name = "test", - srcs = ["test_with_node.sh"], +# Make our program executable and include the linker +# The runfiles here are only the ones included with the program itself +sh_binary( + name = "run_program", + srcs = ["run_program_with_node.sh"], data = [ - ":example", ":program.js", - "//internal/linker:link_node_modules.js", + "//internal/linker:index.js", + "//internal/linker/test/integration/static_linked_pkg", "@bazel_tools//tools/bash/runfiles", "@build_bazel_rules_nodejs//toolchains/node:node_bin", - # TODO: we shouldn't need to repeat this here. There's a bug somewhere + ], +) + +# How a users rule might want to run a node program +linked( + name = "example", + out = "actual", + program = ":run_program", + deps = [ + ":run_program", + "//internal/linker/test/integration/dynamic_linked_pkg", "@npm//semver", ], ) + +golden_file_test( + # default rule in this package + name = "integration", + actual = "actual", + golden = "golden.txt", +) diff --git a/internal/linker/test/integration/dynamic_linked_pkg/BUILD.bazel b/internal/linker/test/integration/dynamic_linked_pkg/BUILD.bazel new file mode 100644 index 0000000000..fa9e6d8705 --- /dev/null +++ b/internal/linker/test/integration/dynamic_linked_pkg/BUILD.bazel @@ -0,0 +1,9 @@ +load("//internal/js_library:js_library.bzl", "js_library") + +package(default_visibility = ["//internal/linker/test:__subpackages__"]) + +js_library( + name = "dynamic_linked_pkg", + srcs = ["index.js"], + module_name = "dynamic_linked", +) diff --git a/internal/linker/test/integration/dynamic_linked_pkg/index.js b/internal/linker/test/integration/dynamic_linked_pkg/index.js new file mode 100644 index 0000000000..4923d5e6cb --- /dev/null +++ b/internal/linker/test/integration/dynamic_linked_pkg/index.js @@ -0,0 +1,5 @@ +function addB(str) { + return `${str}_b`; +} + +exports.addB = addB; \ No newline at end of file diff --git a/internal/linker/test/integration/golden.txt b/internal/linker/test/integration/golden.txt new file mode 100644 index 0000000000..ab8b9eb93f --- /dev/null +++ b/internal/linker/test/integration/golden.txt @@ -0,0 +1 @@ +1.2.3_b_a diff --git a/internal/linker/test/integration/program.js b/internal/linker/test/integration/program.js index 5534c5419a..9feaddb2cc 100644 --- a/internal/linker/test/integration/program.js +++ b/internal/linker/test/integration/program.js @@ -1,6 +1,11 @@ -// First-party package from ./pkg_a -const a = require('a'); +// First-party package from ./static_linked_pkg +// it should get resolved through runfiles +const a = require('static_linked'); +// First-party package from ./dynamic_linked_pkg +// it should get resolved from the execroot +const b = require('dynamic_linked'); // Third-party package installed in the root node_modules const semver = require('semver'); -console.log(a.addA(semver.clean(' =v1.2.3 '))); +// This output should match what's in the golden.txt file +console.log(a.addA(b.addB(semver.clean(' =v1.2.3 ')))); diff --git a/internal/linker/test/integration/rule.bzl b/internal/linker/test/integration/rule.bzl index 4598a82227..66618aac73 100644 --- a/internal/linker/test/integration/rule.bzl +++ b/internal/linker/test/integration/rule.bzl @@ -3,13 +3,20 @@ load("@build_bazel_rules_nodejs//internal/linker:link_node_modules.bzl", "module_mappings_aspect", "register_node_modules_linker") def _linked(ctx): - inputs = [] + inputs = ctx.files.deps[:] + outputs = [ctx.outputs.out] args = ctx.actions.args() register_node_modules_linker(ctx, args, inputs) - return [DefaultInfo( - runfiles = ctx.runfiles(files = inputs + ctx.files.deps), - )] + args.add(ctx.outputs.out.path) + ctx.actions.run( + inputs = inputs, + outputs = outputs, + executable = ctx.executable.program, + arguments = [args], + ) linked = rule(_linked, attrs = { + "out": attr.output(), + "program": attr.label(executable = True, cfg = "host", mandatory = True), "deps": attr.label_list(aspects = [module_mappings_aspect]), }) diff --git a/internal/linker/test/integration/run_program.sh b/internal/linker/test/integration/run_program.sh new file mode 100755 index 0000000000..227b2b8aa3 --- /dev/null +++ b/internal/linker/test/integration/run_program.sh @@ -0,0 +1,71 @@ +#!/usr/bin/env bash +# Copyright 2019 The Bazel Authors. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# This shell script is a minimal fixture for the node_launcher.sh script +# with a critical difference: instead of calling the node_loader.js script +# with the users program passed as an argument (allowing us to patch the node +# loader), this one just runs vanilla node with the users program as the argument +# which lets us assert that the linker is the reason the program works. + +# Immediately exit if any command fails. +set -e + +# Turn on extra logging so that test failures are easier to debug +export VERBOSE_LOGS=1 +export NODE_DEBUG=module + +# --- begin runfiles.bash initialization --- +# Source the runfiles library: +# https://github.com/bazelbuild/bazel/blob/master/tools/bash/runfiles/runfiles.bash +# The runfiles library defines rlocation, which is a platform independent function +# used to lookup the runfiles locations. This code snippet is needed at the top +# of scripts that use rlocation to lookup the location of runfiles.bash and source it +if [[ ! -d "${RUNFILES_DIR:-/dev/null}" && ! -f "${RUNFILES_MANIFEST_FILE:-/dev/null}" ]]; then + if [[ -f "$0.runfiles_manifest" ]]; then + export RUNFILES_MANIFEST_FILE="$0.runfiles_manifest" + elif [[ -f "$0.runfiles/MANIFEST" ]]; then + export RUNFILES_MANIFEST_FILE="$0.runfiles/MANIFEST" + elif [[ -f "$0.runfiles/bazel_tools/tools/bash/runfiles/runfiles.bash" ]]; then + export RUNFILES_DIR="$0.runfiles" + fi +fi +if [[ -f "${RUNFILES_DIR:-/dev/null}/bazel_tools/tools/bash/runfiles/runfiles.bash" ]]; then + source "${RUNFILES_DIR}/bazel_tools/tools/bash/runfiles/runfiles.bash" +elif [[ -f "${RUNFILES_MANIFEST_FILE:-/dev/null}" ]]; then + source "$(grep -m1 "^bazel_tools/tools/bash/runfiles/runfiles.bash " \ + "$RUNFILES_MANIFEST_FILE" | cut -d ' ' -f 2-)" +else + echo >&2 "ERROR: cannot find @bazel_tools//tools/bash/runfiles:runfiles.bash" + exit 1 +fi +# --- end runfiles.bash initialization --- + +for ARG in "$@"; do + case "$ARG" in + --bazel_node_modules_manifest=*) MODULES_MANIFEST="${ARG#--bazel_node_modules_manifest=}" ;; + *) OUT="$ARG" + esac +done + +readonly DIR="build_bazel_rules_nodejs/internal/linker" + +$(rlocation NODE_PATH) \ + $(rlocation $DIR/index.js) \ + $MODULES_MANIFEST + +$(rlocation NODE_PATH) \ + --preserve-symlinks-main \ + $(rlocation $DIR/test/integration/program.js) \ + > $OUT diff --git a/internal/linker/test/integration/pkg_a/BUILD.bazel b/internal/linker/test/integration/static_linked_pkg/BUILD.bazel similarity index 72% rename from internal/linker/test/integration/pkg_a/BUILD.bazel rename to internal/linker/test/integration/static_linked_pkg/BUILD.bazel index 643d07acd5..955a588857 100644 --- a/internal/linker/test/integration/pkg_a/BUILD.bazel +++ b/internal/linker/test/integration/static_linked_pkg/BUILD.bazel @@ -3,7 +3,7 @@ load("//internal/js_library:js_library.bzl", "js_library") package(default_visibility = ["//internal/linker/test:__subpackages__"]) js_library( - name = "pkg_a", + name = "static_linked_pkg", srcs = ["index.js"], - module_name = "a", + module_name = "static_linked", ) diff --git a/internal/linker/test/integration/pkg_a/index.js b/internal/linker/test/integration/static_linked_pkg/index.js similarity index 100% rename from internal/linker/test/integration/pkg_a/index.js rename to internal/linker/test/integration/static_linked_pkg/index.js diff --git a/internal/linker/test/integration/test.sh b/internal/linker/test/integration/test.sh deleted file mode 100755 index fd2a61c348..0000000000 --- a/internal/linker/test/integration/test.sh +++ /dev/null @@ -1,49 +0,0 @@ -#!/usr/bin/env bash -# Copyright 2019 The Bazel Authors. All rights reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -# Immediately exit if any command fails. -set -e - -# Turn on extra logging so that test failures are easier to debug -export VERBOSE_LOGS=1 -export NODE_DEBUG=module - -# --- begin runfiles.bash initialization v2 --- -# Copy-pasted from the Bazel Bash runfiles library v2. -set -uo pipefail; f=bazel_tools/tools/bash/runfiles/runfiles.bash -source "${RUNFILES_DIR:-/dev/null}/$f" 2>/dev/null || \ - source "$(grep -sm1 "^$f " "${RUNFILES_MANIFEST_FILE:-/dev/null}" | cut -f2- -d' ')" 2>/dev/null || \ - source "$0.runfiles/$f" 2>/dev/null || \ - source "$(grep -sm1 "^$f " "$0.runfiles_manifest" | cut -f2- -d' ')" 2>/dev/null || \ - source "$(grep -sm1 "^$f " "$0.exe.runfiles_manifest" | cut -f2- -d' ')" 2>/dev/null || \ - { echo>&2 "ERROR: cannot find $f"; exit 1; }; f=; set -e -# --- end runfiles.bash initialization v2 --- - -readonly DIR="${TEST_WORKSPACE}/internal/linker" - -$(rlocation NODE_PATH) \ - $(rlocation $DIR/link_node_modules.js)\ - $(rlocation $DIR/test/integration/_example.module_mappings.json) - -readonly ACTUAL=$( - $(rlocation NODE_PATH) \ - --preserve-symlinks-main \ - $(rlocation $DIR/test/integration/program.js) -) - -if [[ "$ACTUAL" != "1.2.3_a" ]]; then - echo "expected 1.2.3_a but was ${out}" >&2 - exit 1 -fi diff --git a/internal/linker/test/link_node_modules.spec.js b/internal/linker/test/link_node_modules.spec.js deleted file mode 100644 index 779072a805..0000000000 --- a/internal/linker/test/link_node_modules.spec.js +++ /dev/null @@ -1,58 +0,0 @@ -const linker = require('../link_node_modules'); -const fs = require('fs'); -const path = require('path'); -function mkdirp(p) { - if (!fs.existsSync(p)) { - mkdirp(path.dirname(p)); - fs.mkdirSync(p); - } -} - -describe('link_node_modules', () => { - it('should report when modules manifest absent', () => { - try { - linker.main(); - } catch (expected) { - expect(expected.message).toContain('requires one argument'); - } - try { - linker.main([]); - } catch (expected) { - expect(expected.message).toContain('requires one argument'); - } - try { - linker.main(['bad_path']); - } catch (expected) { - expect(expected.message).toContain('ENOENT'); - } - }); - it('should handle first-party packages only', () => { - process.chdir(process.env['TEST_TMPDIR']); - - // Create a package in a different workspace - mkdirp('other_wksp/path/to/lib_a'); - fs.writeFileSync('other_wksp/path/to/lib_a/index.js', 'exports = {}', {encoding: 'utf-8'}); - // Create our local workspace where the build is running - mkdirp('wksp_1'); - // Set the cwd() like Bazel would in the execroot - process.chdir('wksp_1'); - - // Mock out the creation of the modules manifest - fs.writeFileSync( - 'manifest.json', - JSON.stringify( - { - 'modules': {'a': 'other_wksp/path/to/lib_a'}, - }, - null, 2), - {encoding: 'utf-8'}); - - linker.main(['manifest.json']); - - // The linker expects to run as its own process, so it changes the wd - process.chdir(process.env['TEST_TMPDIR']); - expect(fs.readdirSync('wksp_1')).toContain('node_modules'); - expect(fs.readdirSync('wksp_1/node_modules')).toContain('a'); - expect(fs.readdirSync('wksp_1/node_modules/a')).toContain('index.js'); - }); -}); \ No newline at end of file diff --git a/internal/linker/test/link_node_modules.spec.ts b/internal/linker/test/link_node_modules.spec.ts new file mode 100644 index 0000000000..0262e8fbcc --- /dev/null +++ b/internal/linker/test/link_node_modules.spec.ts @@ -0,0 +1,91 @@ +import * as fs from 'fs'; +import * as path from 'path'; + +import * as linker from '../link_node_modules'; + +function mkdirp(p: string) { + if (!fs.existsSync(p)) { + mkdirp(path.dirname(p)); + fs.mkdirSync(p); + } +} + +// Mock out the creation of the modules manifest +function writeManifest(o: {}) { + fs.writeFileSync('manifest.json', JSON.stringify(o, null, 2), 'utf-8'); +} + +function writeRunfiles(manifest: string[]) { + fs.writeFileSync('runfiles.mf', manifest.join('\n'), 'utf-8'); + process.env['RUNFILES_MANIFEST_FILE'] = 'runfiles.mf'; +} + +describe('link_node_modules', () => { + let workspace: string; + + beforeEach(() => { + process.chdir(process.env['TEST_TMPDIR']!); + // Prevent test isolation failures: each spec gets its own workspace + workspace = `wksp_${Date.now()}`; + // Create our local workspace where the build is running + mkdirp(workspace); + }); + + it('should report when modules manifest absent', () => { + try { + (linker as any).main(); + } catch (expected) { + expect(expected.message).toContain('requires one argument'); + } + try { + (linker as any).main([]); + } catch (expected) { + expect(expected.message).toContain('requires one argument'); + } + try { + (linker as any).main(['bad_path']); + } catch (expected) { + expect(expected.message).toContain('ENOENT'); + } + }); + + it('should handle first-party packages in workspace', () => { + // Set the cwd() like Bazel would in the execroot + process.chdir(workspace); + + // Create a package in a different workspace + mkdirp('external/other_wksp/path/to/lib_a'); + fs.writeFileSync('external/other_wksp/path/to/lib_a/index.js', 'exports = {}', 'utf-8'); + + writeManifest({ + 'modules': {'a': 'other_wksp/path/to/lib_a'}, + 'workspace': workspace, + }); + + linker.main(['manifest.json'], {dir: process.env['RUNFILES_DIR']} as any); + + // The linker expects to run as its own process, so it changes the wd + process.chdir(path.join()); + expect(fs.readdirSync(path.join(process.env['TEST_TMPDIR']!, workspace, 'node_modules', 'a'))) + .toContain('index.js'); + }); + + it('should handle third-party packages in runfiles', () => { + mkdirp('npm/node_modules/some-package'); + const idx = 'npm/node_modules/some-package/index.js'; + fs.writeFileSync(idx, 'exports = {}', 'utf-8'); + const runfilesManifest = [`${idx} ${path.resolve(idx)}`]; + + // Set the cwd() like Bazel would in the execroot + process.chdir(workspace); + // No first-party packages + writeManifest({'root': 'npm/node_modules'}); + writeRunfiles(runfilesManifest); + + linker.main(['manifest.json'], new linker.Runfiles()); + + // The linker expects to run as its own process, so it changes the wd + process.chdir(path.join(process.env['TEST_TMPDIR']!, workspace)); + expect(fs.readdirSync(path.join('node_modules', 'some-package'))).toContain('index.js'); + }); +}); \ No newline at end of file diff --git a/packages/typescript/src/index.from_src.bzl b/packages/typescript/src/index.from_src.bzl index ad0eb32c37..eb99dae621 100644 --- a/packages/typescript/src/index.from_src.bzl +++ b/packages/typescript/src/index.from_src.bzl @@ -15,6 +15,7 @@ """ Defaults for usage without @npm//@bazel/typescript """ +load("@build_bazel_rules_nodejs//internal/golden_file_test:golden_file_test.bzl", "golden_file_test") load( ":index.bzl", _ts_devserver = "ts_devserver", @@ -32,3 +33,37 @@ def ts_library(**kwargs): compiler = "@build_bazel_rules_typescript//internal:tsc_wrapped_bin", **kwargs ) + +# In rules_nodejs "builtin" package, we are creating the toolchain for building +# tsc-wrapped and executing ts_library, so we cannot depend on them. +# However, we still want to be able to write our tooling in TypeScript. +# This macro lets us check in the resulting .js files, and still ensure that they are +# compiled from the .ts by using a golden file test. +def checked_in_ts_library(name, checked_in_js, **kwargs): + ts_library( + name = name, + **kwargs + ) + + native.filegroup( + name = "_%s_es5" % name, + srcs = [name], + output_group = "es5_sources", + ) + + # Don't trigger clang-format on the output js + # Make sure we don't add any lines though, since that would + # break the sourcemap + native.genrule( + name = "_%s_skip_formatting" % name, + srcs = ["_%s_es5" % name], + outs = ["_%s_es5_no_format.js" % name], + cmd = """echo -n "/* THIS FILE GENERATED FROM .ts; see BUILD.bazel */ /* clang-format off */" > $@; cat $< >> $@""", + ) + + # Assert that we kept the index.js up-to-date when changing the TS code + golden_file_test( + name = "%s_check_compiled" % name, + actual = "_%s_es5_no_format.js" % name, + golden = checked_in_js, + ) diff --git a/tsconfig.json b/tsconfig.json index 62c6042ed1..5cf749abe4 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -1,6 +1,7 @@ { "compilerOptions": { "lib": ["es2015", "dom"], - "strict": true + "strict": true, + "target": "es2015" } }