Explicitly list Node architectures

Updates Dawn's NodeJS dependency to explicitly fetch CIPD packages for
all supported architectures for an OS instead of relying on
${{platform}}. Users of this dependency are also updated to select the
correct copy based on the OS/arch combination at runtime.

This is necessary in order to properly support running Node-based tests
on OSes that support multiple architectures. Using ${{platform}} when
fetching dependencies implicitly assumes that the architecture of the
machine fetching dependencies/building is the same as the machine that
will run tests. This assumption does not hold true now that we support
running tests on Swarming, as Mac in particular prefers to build on
arm64 regardless of which architecture is being built for.

Bug: 441328362
Change-Id: Ida2786ff421e35effc812d40a83af951ef3dbb48
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/264634
Auto-Submit: Brian Sheedy <[email protected]>
Reviewed-by: Yuly Novikov <[email protected]>
Commit-Queue: Yuly Novikov <[email protected]>

Author: bsheedy-work

DEPS

@@ -390,15 +390,68 @@ deps = {
     'condition': 'dawn_node',
   },
 
-  # Node binaries, when dawn_node or dawn_wasm is enabled
-  'third_party/node': {
+  # Node binaries, when dawn_node or dawn_wasm is enabled. Architectures are
+  # listed out explicitly instead of using ${{platform}} because the
+  # architecture that these are fetched on can differ from the architecture that
+  # tests are ultimately run on, such as x64 vs. ARM64 Mac.
+  'third_party/node/linux-amd64': {
     'packages': [
       {
-        'package': 'infra/3pp/tools/nodejs/${{platform}}',
+        'package': 'infra/3pp/tools/nodejs/linux-amd64',
         'version': Var('dawn_node_version'),
       },
     ],
-    'condition': 'dawn_node or dawn_wasm',
+    'condition': 'checkout_linux and (dawn_node or dawn_wasm)',
+    'dep_type': 'cipd',
+  },
+  'third_party/node/linux-arm64': {
+    'packages': [
+      {
+        'package': 'infra/3pp/tools/nodejs/linux-arm64',
+        'version': Var('dawn_node_version'),
+      },
+    ],
+    'condition': 'checkout_linux and (dawn_node or dawn_wasm)',
+    'dep_type': 'cipd',
+  },
+  'third_party/node/mac-amd64': {
+    'packages': [
+      {
+        'package': 'infra/3pp/tools/nodejs/mac-amd64',
+        'version': Var('dawn_node_version'),
+      },
+    ],
+    'condition': 'checkout_mac and (dawn_node or dawn_wasm)',
+    'dep_type': 'cipd',
+  },
+  'third_party/node/mac-arm64': {
+    'packages': [
+      {
+        'package': 'infra/3pp/tools/nodejs/mac-arm64',
+        'version': Var('dawn_node_version'),
+      },
+    ],
+    'condition': 'checkout_mac and (dawn_node or dawn_wasm)',
+    'dep_type': 'cipd',
+  },
+  'third_party/node/windows-amd64': {
+    'packages': [
+      {
+        'package': 'infra/3pp/tools/nodejs/windows-amd64',
+        'version': Var('dawn_node_version'),
+      },
+    ],
+    'condition': 'checkout_win and (dawn_node or dawn_wasm)',
+    'dep_type': 'cipd',
+  },
+  'third_party/node/windows-arm64': {
+    'packages': [
+      {
+        'package': 'infra/3pp/tools/nodejs/windows-arm64',
+        'version': Var('dawn_node_version'),
+      },
+    ],
+    'condition': 'checkout_win and (dawn_node or dawn_wasm)',
     'dep_type': 'cipd',
   },
 

scripts/dawn_node_cts/node_helpers.py

@@ -28,11 +28,56 @@
 
 import functools
 import os
+import platform
 import sys
 
 THIS_DIR = os.path.dirname(__file__)
 DAWN_ROOT = os.path.realpath(os.path.join(THIS_DIR, '..', '..'))
-NODE_DIR = os.path.join(DAWN_ROOT, 'third_party', 'node')
+
+
+@functools.cache
+def get_node_dir() -> str:
+    """Retrieves the directory that NodeJS should be available in."""
+    cipd_os = get_cipd_compatible_current_os()
+    cipd_arch = get_cipd_compatible_current_arch()
+    cipd_platform = f'{cipd_os}-{cipd_arch}'
+    return os.path.join(DAWN_ROOT, 'third_party', 'node', cipd_platform)
+
+
+@functools.cache
+def get_cipd_compatible_current_os() -> str:
+    """Retrieves the current OS name.
+
+    The returned string is compatible with CIPD's package naming scheme.
+    """
+    current_platform = sys.platform
+    if current_platform in ('linux', 'cygwin'):
+        return 'linux'
+    if current_platform == 'win32':
+        return 'windows'
+    if current_platform == 'darwin':
+        return 'mac'
+    raise ValueError(f'Unknown platform {current_platform}')
+
+
+@functools.cache
+def get_cipd_compatible_current_arch() -> str:
+    """Retrieves the current architecture.
+
+    The returned string is compatible with CIPD's package naming scheme.
+    """
+    native_arm = platform.machine().lower() in ('arm', 'arm64')
+    # This is necessary for the case of running x86 Python on arm devices via
+    # an emulator. In this case, platform.machine() will show up as an x86
+    # processor.
+    emulated_x86 = 'armv8' in platform.processor().lower()
+    if native_arm or emulated_x86:
+        return 'arm64'
+
+    native_x86 = platform.machine().lower() in ('x86', 'x86_64', 'amd64')
+    if native_x86:
+        return 'amd64'
+    raise ValueError('Unable to determine architecture')
 
 
 @functools.cache
@@ -42,12 +87,12 @@ def get_node_path() -> str:
     Returns:
         A filepath to the standalone node executable.
     """
-    path = os.path.join(NODE_DIR, 'bin', 'node')
+    path = os.path.join(get_node_dir(), 'bin', 'node')
     if sys.platform == 'win32':
-        path = os.path.join(NODE_DIR, 'node.exe')
+        path = os.path.join(get_node_dir(), 'node.exe')
     if not os.path.exists(path):
         raise RuntimeError(
-            f'Unable to find the node binary under {NODE_DIR}. Is the '
+            f'Unable to find the node binary under {get_node_dir()}. Is the '
             f'dawn_node gclient variable set?')
     return path
 
@@ -60,18 +105,18 @@ def get_npm_command() -> list[str]:
         A list of strings that will run "npm" when run as a command for a
         subprocess.
     """
-    path = os.path.join(NODE_DIR, 'lib', 'node_modules', 'npm', 'bin',
+    path = os.path.join(get_node_dir(), 'lib', 'node_modules', 'npm', 'bin',
                         'npm-cli.js')
     if sys.platform == 'win32':
-        path = os.path.join(NODE_DIR, 'node_modules', 'npm', 'bin',
+        path = os.path.join(get_node_dir(), 'node_modules', 'npm', 'bin',
                             'npm-cli.js')
     if not os.path.exists(path):
         raise RuntimeError(
-            f'Unable to find the npm-cli.js file under {NODE_DIR}. Is the '
+            f'Unable to find the npm-cli.js file under {get_node_dir()}. Is the '
             f'dawn_node gclient variable set?')
     cmd = [
         get_node_path(),
-        os.path.join(NODE_DIR, path),
+        os.path.join(get_node_dir(), path),
     ]
     return cmd
 

tools/src/fileutils/paths.go

@@ -100,11 +100,19 @@ func NodePath(fsReader oswrapper.FilesystemReader) string {
 		node := filepath.Join(dawnRoot, "third_party", "node")
 		if info, err := fsReader.Stat(node); err == nil && info.IsDir() {
 			path := ""
-			switch runtime.GOOS { // See `go tool dist list`
-			case "windows":
-				path = filepath.Join(node, "node.exe")
-			default:
-				path = filepath.Join(node, "bin", "node")
+			switch fmt.Sprintf("%v/%v", runtime.GOOS, runtime.GOARCH) { // See `go tool dist list`
+			case "darwin/amd64":
+				path = filepath.Join(node, "mac-amd64", "bin", "node")
+			case "darwin/arm64":
+				path = filepath.Join(node, "mac-arm64", "bin", "node")
+			case "linux/amd64":
+				path = filepath.Join(node, "linux-amd64", "bin", "node")
+			case "linux/arm64":
+				path = filepath.Join(node, "linux-arm64", "bin", "node")
+			case "windows/amd64":
+				path = filepath.Join(node, "windows-amd64", "node.exe")
+			case "windows/arm64":
+				path = filepath.Join(node, "windows-arm64", "node.exe")
 			}
 			if _, err := fsReader.Stat(path); err == nil {
 				return path