| #!/usr/bin/env fuchsia-vendored-python |
| # Copyright 2022 The Fuchsia Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| """Wraps a Rust compile command for remote execution (reclient, RBE). |
| |
| Given a Rust compile command, this script |
| 1) identifies all inputs needed to execute the command hermetically (remotely). |
| 2) identifies all outputs to be retrieved from remote execution. |
| 3) composes a `rewrapper` (reclient) command to request remote execution. |
| This includes downloading remotely produced artifacts. |
| 4) forwards stdout/stderr back to the local environment |
| |
| This script was ported over from build/rbe/rustc-remote-wrapper.sh. |
| |
| For full usage, see `rustc_remote_wrapper.py -h`. |
| """ |
| |
| import argparse |
| import glob |
| import os |
| import subprocess |
| import stat |
| import sys |
| |
| import cl_utils |
| import depfile |
| import fuchsia |
| import linker |
| import rustc |
| import remote_action |
| |
| from pathlib import Path |
| from typing import Any, Iterable, Optional, Sequence |
| |
| _SCRIPT_BASENAME = Path(__file__).name |
| |
| # standard '755' executable permissions |
| _EXEC_PERMS = ( |
| stat.S_IRWXU | (stat.S_IRGRP | stat.S_IXGRP) | (stat.S_IROTH | stat.S_IXOTH) |
| ) |
| |
| |
| def msg(text: str): |
| print(f"[{_SCRIPT_BASENAME}] {text}") |
| |
| |
| # string.removeprefix() only appeared in python 3.9 |
| def remove_prefix(text: str, prefix: str) -> str: |
| if text.startswith(prefix): |
| return text[len(prefix) :] |
| return text |
| |
| |
| # This is needed in some places to workaround b/203540556 (reclient). |
| def remove_dot_slash_prefix(text: str) -> str: |
| return remove_prefix(text, "./") |
| |
| |
| # string.removesuffix() only appeared in python 3.9 |
| def remove_suffix(text: str, suffix: str) -> str: |
| if text.endswith(suffix): |
| return text[: -len(suffix)] |
| return text |
| |
| |
| # Defined for convenient mocking. |
| def _readlines_from_file(path: Path) -> Sequence[str]: |
| return path.read_text().splitlines(keepends=True) |
| |
| |
| # Defined for convenient mocking. |
| def _make_local_depfile(command: Sequence[str]) -> int: |
| return subprocess.call(command) |
| |
| |
| # Defined for convenient mocking. |
| def _tool_is_executable(tool: Path) -> bool: |
| return os.access(tool, os.X_OK) |
| |
| |
| # Defined for convenient mocking. |
| def _libcxx_isfile(libcxx: Path) -> bool: |
| return libcxx.is_file() |
| |
| |
| # Defined for convenient mocking. |
| def _env_file_exists(path: Path) -> bool: |
| return path.exists() |
| |
| |
| def _flatten_comma_list_to_paths(items: Iterable[str]) -> Iterable[Path]: |
| for item in cl_utils.flatten_comma_list(items): |
| yield Path(item) |
| |
| |
| def _main_arg_parser() -> argparse.ArgumentParser: |
| """Construct the argument parser, called by main().""" |
| parser = argparse.ArgumentParser( |
| description="Prepares a Rust compile command for remote execution.", |
| argument_default=[], |
| ) |
| remote_action.inherit_main_arg_parser_flags(parser) |
| |
| # There could be multiple variants of the standard C++ library to choose |
| # from. Use the one that corresponds to the compiler options. |
| parser.add_argument( |
| "--cxx-stdlibdir", |
| type=Path, |
| default=None, |
| help="Where to find libc++ (from clang)", |
| ) |
| |
| return parser |
| |
| |
| _MAIN_ARG_PARSER = _main_arg_parser() |
| |
| |
| def relativize_paths(paths: Iterable[Path], start: Path) -> Iterable[Path]: |
| for p in paths: |
| if p.is_absolute(): |
| yield cl_utils.relpath(p, start=start) |
| else: |
| yield p # Paths are already normalized upon construction |
| |
| |
| def accompany_rlib_with_so(deps: Iterable[Path]) -> Iterable[Path]: |
| """Expand list to include .so files. |
| |
| Some Rust libraries come with both .rlib and .so (like libstd), however, |
| the depfile generator fails to list the .so file in some cases, |
| which causes the build to silently fallback to static linking when |
| dynamic linking is requested and intended. This can result in a mismatch |
| between local and remote building. |
| See https://github.com/rust-lang/rust/issues/90106 |
| Workaround (https://fxbug.dev/42167956): check for existence of .so and include it. |
| |
| Yields: |
| original sequence, plus potentially additional .so libs. |
| """ |
| for dep in deps: |
| yield dep |
| if dep.suffix == ".rlib": |
| so_file = dep.with_suffix(".so") # replaces .rlib with .so |
| if so_file.is_file(): |
| yield so_file |
| |
| |
| def expand_deps_for_rlib_compile(paths: Iterable[Path]) -> Iterable[Path]: |
| """Expand a list of rmeta deps to be suitable for full (rlib) compilation. |
| |
| Depending on the rustc options used for scanning for dependencies, |
| the deps may contain list the .rmeta metadata file for some |
| entries (because only metadata is needed for fast operations like |
| dep-scanning). However, for the purposes of compiling a real .rlib |
| (or other rust artifact) we need to interpret this as requiring the |
| corresponding .rlib. |
| The implied .rlib need not necessarily exist on disk with real |
| contents; it is permitted to be a download stub from an earlier |
| remote build. |
| |
| Yields: |
| possibly modified deps. |
| """ |
| for path in paths: |
| yield path |
| if path.name.endswith(".rmeta"): |
| f = path.with_suffix(".rlib") |
| if f.exists(): # ok to exist as download stub |
| yield f |
| continue |
| |
| # .so proc macros already appear as deps in the depfile |
| # so there is no need to repeat them here. |
| pass |
| |
| |
| class RemoteInputProcessingError(RuntimeError): |
| def __init__(self, message: str): |
| super().__init__(message) |
| |
| |
| def _filter_local_command(args: Iterable[str]) -> Sequence[str]: |
| return list(cl_utils.strip_option_prefix(args, "--local-only")) |
| |
| |
| class RustRemoteAction(object): |
| def __init__( |
| self, |
| argv: Sequence[str], |
| exec_root: Optional[Path] = None, |
| working_dir: Optional[Path] = None, |
| host_platform: str = None, |
| auto_reproxy: bool = True, # Ok to disable during unit-tests |
| ): |
| self._working_dir = (working_dir or Path(os.curdir)).absolute() |
| self._exec_root = (exec_root or remote_action.PROJECT_ROOT).absolute() |
| self._host_platform = host_platform or fuchsia.HOST_PREBUILT_PLATFORM |
| |
| # Propagate --remote-flag=... options to the remote prefix, |
| # as if they appeared before '--'. |
| # Forwarded rewrapper options with values must be written as '--flag=value', |
| # not '--flag value' because argparse doesn't know what unhandled flags |
| # expect values. |
| main_argv, filtered_command = remote_action.forward_remote_flags(argv) |
| |
| # Forward all unknown flags to rewrapper |
| # --help here will result in early exit() |
| ( |
| self._main_args, |
| self._main_remote_options, |
| ) = _MAIN_ARG_PARSER.parse_known_args(main_argv) |
| |
| # Re-launch with reproxy if needed. |
| if auto_reproxy: |
| remote_action.auto_relaunch_with_reproxy( |
| script=Path(__file__), argv=argv, args=self._main_args |
| ) |
| |
| if not filtered_command: # there is no command, bail out early |
| return |
| |
| self._rust_action = rustc.RustAction( |
| command=filtered_command, |
| working_dir=self.working_dir, |
| ) |
| |
| # TODO: check for missing required flags, like --target |
| |
| self._local_only = self._main_args.local or self._remote_disqualified() |
| |
| self._cleanup_files: Sequence[Path] = [] |
| self._prepare_status: int = None # 0 means success, like an exit code |
| self._remote_action = None # will be set by prepare() step |
| |
| @property |
| def _c_sysroot_is_outside_exec_root(self) -> bool: |
| c_sysroot_dir = self.c_sysroot |
| if not c_sysroot_dir: |
| return False # not applicable |
| |
| if not c_sysroot_dir.is_absolute(): |
| # C sysroot is relative to the working directory |
| return False |
| |
| # Check all absolute path parents. |
| return self.exec_root not in c_sysroot_dir.parents |
| |
| def _remote_disqualified(self): |
| """Detects when the action cannot run remotely for various reasons.""" |
| # If the C sysroot is outside of exec_root, (e.g. an absolute path |
| # like /Library/Developer/... for Mac OS SDKs) then the command |
| # will only work locally. |
| if self.needs_linker: |
| if self._c_sysroot_is_outside_exec_root: |
| self.vmsg( |
| f"Forcing local execution because C sysroot ({self.c_sysroot}) is outside of exec_root ({self.exec_root})." |
| ) |
| return True |
| |
| # TODO: procedural macros need to target the host AND the remote |
| # platform to be usable both locally and remotely. |
| # For now, only build with procedural macros locally. |
| if any( |
| path.suffix == ".dylib" |
| for path in self._rust_action.externs.values() |
| ): |
| self.vmsg( |
| f"Forcing local execution because one of the externs points to a .dylib, which does not work in the remote environment." |
| ) |
| return True |
| |
| return False |
| |
| @property |
| def verbose(self) -> bool: |
| return self._main_args.verbose |
| |
| def vmsg(self, text: str): |
| if self.verbose: |
| msg(text) |
| |
| @property |
| def dry_run(self) -> bool: |
| return self._main_args.dry_run |
| |
| @property |
| def check_determinism(self) -> bool: |
| return self._main_args.check_determinism |
| |
| @property |
| def determinism_attempts(self) -> int: |
| return self._main_args.determinism_attempts |
| |
| @property |
| def miscomparison_export_dir(self) -> Optional[Path]: |
| if self._main_args.miscomparison_export_dir: |
| return self.working_dir / self._main_args.miscomparison_export_dir |
| return None |
| |
| @property |
| def clang_cxx_stdlibdir(self) -> Optional[Path]: |
| return self._main_args.cxx_stdlibdir |
| |
| @property |
| def local_only(self) -> bool: |
| """If the conditions are not right for remote execution, disable, |
| regardless of configuration. |
| """ |
| return self._local_only |
| |
| @property |
| def label(self) -> str: |
| return self._main_args.label |
| |
| def vmsg(self, text: str): |
| if self.verbose: |
| msg(text) |
| |
| def value_verbose(self, desc: str, value: str) -> str: |
| """In verbose mode, print and forward value.""" |
| self.vmsg(f"{desc}: {value}") |
| return value |
| |
| def yield_verbose(self, desc: str, items: Iterable[Any]) -> Iterable[Any]: |
| """In verbose mode, print and forward items. |
| |
| Args: |
| desc: text description of what is being printed. |
| items: stream of any type of object that is str-able. |
| |
| Yields: |
| items, unchanged |
| """ |
| if self.verbose: |
| msg(f"{desc}: {{") |
| for item in items: |
| print(f" {item}") # one item per line |
| yield item |
| print(f"}} # {desc}") |
| else: |
| yield from items |
| |
| @property |
| def working_dir(self) -> Path: |
| return self._working_dir |
| |
| @property |
| def exec_root(self) -> Path: |
| return self._exec_root |
| |
| @property |
| def label(self) -> Optional[str]: |
| return self._main_args.label |
| |
| @property |
| def host_platform(self) -> str: |
| return self._host_platform |
| |
| @property |
| def exec_root_rel(self) -> Path: |
| # relpath can handle cases that Path.relative_to() cannot. |
| return cl_utils.relpath(self.exec_root, start=self.working_dir) |
| |
| @property |
| def build_subdir(self) -> Path: # relative |
| """This is the relative path from the exec_root to the current working dir.""" |
| return self.working_dir.relative_to(self.exec_root) |
| |
| @property |
| def crate_type(self) -> rustc.CrateType: |
| return self._rust_action.crate_type |
| |
| @property |
| def needs_linker(self) -> bool: |
| return self._rust_action.needs_linker |
| |
| @property |
| def target(self) -> Optional[str]: |
| return self._rust_action.target |
| |
| @property |
| def rust_sysroot(self) -> Optional[Path]: |
| return self._rust_action.rust_sysroot |
| |
| @property |
| def c_sysroot(self) -> Optional[Path]: |
| return self._rust_action.c_sysroot |
| |
| @property |
| def linker(self) -> Optional[Path]: |
| return self._rust_action.linker |
| |
| @property |
| def local_clang_toolchain_dir(self) -> Path: |
| """Infer the clang toolchain dir based on the linker location. |
| |
| Returns: |
| Path to a toolchain dir, relative to the working dir. |
| """ |
| linker = self.linker # a relative path |
| if not linker: |
| return self.exec_root_rel / fuchsia.REMOTE_CLANG_SUBDIR |
| # We want TOOLDIR from a path like TOOLDIR/bin/TOOL. |
| # This follows a typical clang install structure. |
| return linker.parent.parent |
| |
| @property |
| def remote_clang_toolchain_dir(self) -> Path: # relative |
| return fuchsia.remote_executable(self.local_clang_toolchain_dir) |
| |
| @property |
| def depfile(self) -> Optional[Path]: |
| return self._rust_action.depfile |
| |
| @property |
| def primary_output(self) -> Path: |
| return self._rust_action.output_file |
| |
| @property |
| def host_compiler(self) -> Path: |
| return self._rust_action.compiler |
| |
| @property |
| def remote_compiler(self) -> Path: |
| return fuchsia.remote_executable(self.host_compiler) |
| |
| @property |
| def host_matches_remote(self) -> bool: |
| return self.remote_compiler == self.host_compiler |
| |
| @property |
| def original_command(self) -> Sequence[str]: |
| return self._rust_action.original_command |
| |
| def _replace_with_remote_compiler(self, tok) -> Optional[str]: |
| if tok == str(self.host_compiler): |
| return str(self.remote_compiler) |
| |
| @staticmethod |
| def _replace_with_remote_linker(tok) -> Optional[str]: |
| """Replace the host platform linker with the remote platform one.""" |
| return cl_utils.match_prefix_transform_suffix( |
| tok, "-Clinker=", lambda x: str(fuchsia.remote_executable(Path(x))) |
| ) |
| |
| @staticmethod |
| def _normalize_libcxx(tok) -> Optional[str]: |
| # A path like ".../bin/../lib/libc++a" needs to be normalized |
| # so that the remote linker does not fail when looking for a |
| # non-existent "bin" part of the path. |
| prefix = "-Clink-arg=" |
| if tok.startswith(prefix) and tok.endswith(".a") and ".." in tok: |
| right = tok[len(prefix) :] |
| # We do not want the Path.resolve() behavior of following |
| # symlinks and checking for existence; we truly want simple |
| # os.path.normpath() behavior. |
| normpath = os.path.normpath(right) |
| return prefix + normpath |
| |
| @property |
| def local_depfile(self) -> Path: |
| return Path(str(self.depfile) + ".nolink") |
| |
| @property |
| def dep_only_command(self) -> Sequence[str]: |
| return cl_utils.auto_env_prefix_command( |
| _filter_local_command( |
| self._rust_action.dep_only_command(self.local_depfile) |
| ) |
| ) |
| |
| def remote_compile_command(self) -> Iterable[str]: |
| """Transforms a local command into the remotely executed command. |
| |
| Note: that response files are preserved, so tokens inside response files |
| cannot be modified. |
| """ |
| for tok in self.original_command: |
| # Apply the first matching transform on each token. |
| replacement = self._replace_with_remote_compiler(tok) |
| if replacement is not None: |
| yield replacement |
| continue |
| |
| replacement = self._replace_with_remote_linker(tok) |
| if replacement is not None: |
| yield replacement |
| continue |
| |
| replacement = self._normalize_libcxx(tok) |
| if replacement is not None: |
| yield replacement |
| continue |
| |
| # When using -fuse-ld, also hint at the full path to the |
| # linker tool that is expected, without having to prepend |
| # PATH in the remote environment. |
| # This is only needed for remote cross-compilation. |
| if ( |
| tok.startswith("-Clink-arg=-fuse-ld=") |
| and not self.host_matches_remote |
| ): |
| yield tok |
| yield f"-Clink-arg=--ld-path={self.remote_ld_path}" |
| continue |
| |
| # else |
| yield tok |
| |
| # TODO(https://fxbug.dev/42057067): relocate rust sysroot to |
| # be indepedent of host-platform to make remote commands |
| # match for better caching. |
| # The rust sysroot is home to the standard libraries for |
| # all target platforms. |
| # Fuchsia currently uses the default sysroot location which is |
| # based on the *host* compiler path, but the remote compiler's |
| # default sysroot will be different. |
| # Inform the remote compiler to use the location of the sysroot |
| # of the *host* compiler. |
| fuchsia_use_host_rust_sysroot = self._rust_action.default_rust_sysroot() |
| yield f"--sysroot={fuchsia_use_host_rust_sysroot}" |
| |
| def _cleanup(self): |
| for f in self._cleanup_files: |
| f.unlink(missing_ok=True) # does remove or rmdir |
| |
| def _local_depfile_inputs(self) -> Iterable[Path]: |
| # Generate a local depfile for the purposes of discovering |
| # all transitive inputs. |
| self._cleanup_files.append(self.local_depfile) |
| |
| dep_only_command = self.dep_only_command |
| cmd_str = cl_utils.command_quoted_str(dep_only_command) |
| self.vmsg(f"scan-deps-only command: {cmd_str}") |
| dep_status = _make_local_depfile(dep_only_command) |
| if dep_status != 0: |
| self._prepare_status = dep_status |
| if self.verbose: |
| # This is really a lot of information, which is only interesting |
| # in limited circumstances. So we don't print it unless requested. |
| raise RemoteInputProcessingError( |
| f"Error: Local generation of depfile failed (exit={dep_status}): {cmd_str}" |
| ) |
| else: |
| raise RemoteInputProcessingError( |
| f"Error: Local generation of depfile failed (exit={dep_status}), use --verbose to see the command line." |
| ) |
| |
| # There is a phony dep for each input that is needed. |
| deps = list( |
| depfile.parse_lines(_readlines_from_file(self.local_depfile)) |
| ) |
| target_paths = [dep.target_paths for dep in deps if dep.is_phony] |
| remote_depfile_inputs = [ |
| target for paths in target_paths for target in paths |
| ] |
| |
| # Expand some .rmeta deps for .rlib compilation. |
| expanded_remote_inputs = list( |
| expand_deps_for_rlib_compile(remote_depfile_inputs) |
| ) |
| |
| # TODO: if needed, transform the rust std lib paths, depending on |
| # Fuchsia directory layout of Rust prebuilt libs. |
| # See remap_remote_rust_lib() in rustc-remote-wrapper.sh |
| # for one possible implementation. |
| yield from self.yield_verbose( |
| "depfile inputs", |
| relativize_paths( |
| accompany_rlib_with_so(expanded_remote_inputs), self.working_dir |
| ), |
| ) |
| |
| def _remote_compiler_inputs(self) -> Iterable[Path]: |
| # remote compiler is an input |
| remote_compiler = self.remote_compiler |
| if not _tool_is_executable(remote_compiler): |
| raise RemoteInputProcessingError( |
| f"Remote compilation requires {remote_compiler} to be available for uploading, but it is missing." |
| ) |
| yield self.value_verbose("remote compiler", remote_compiler) |
| yield from self._remote_rustc_shlibs() |
| |
| def _remote_rustc_shlibs(self) -> Iterable[Path]: |
| """Find remote compiler shared libraries. |
| |
| Yields: |
| shared library paths relative to current working dir. |
| """ |
| if self.host_platform == fuchsia.REMOTE_PLATFORM: |
| # remote and host execution environments match |
| yield from self.yield_verbose( |
| "remote compiler shlibs (detected)", |
| relativize_paths( |
| remote_action.host_tool_nonsystem_shlibs( |
| self.remote_compiler |
| ), |
| self.working_dir, |
| ), |
| ) |
| else: |
| yield from self._assumed_remote_rustc_shlibs() |
| |
| def _assumed_remote_rustc_shlibs(self) -> Iterable[Path]: |
| # KLUDGE: the host's binutils may not be able to analyze the remote |
| # executable (ELF), so hardcode what we think the shlibs are. |
| yield from self.yield_verbose( |
| "remote compiler shlibs (guessed)", |
| fuchsia.remote_rustc_shlibs(self.exec_root_rel), |
| ) |
| |
| def _rust_stdlib_libunwind_inputs(self) -> Iterable[Path]: |
| # The majority of stdlibs already appear in dep-info and are uploaded |
| # as needed. However, libunwind.a is not listed, but is directly |
| # needed by code emitted by rustc. Listing this here works around a |
| # missing upload issue, and adheres to the guidance of listing files |
| # instead of whole directories. |
| if not self.target: |
| return |
| libunwind_a = ( |
| self.rust_sysroot |
| / fuchsia.rust_stdlib_subdir( # relative to self.working_dir |
| target_triple=self.target |
| ) |
| / "libunwind.a" |
| ) |
| if libunwind_a.exists(): |
| yield self.value_verbose("libunwind", libunwind_a) |
| |
| def _inputs_from_env(self) -> Iterable[Path]: |
| """Scan command environment variables for references to inputs files. |
| |
| If a variable value looks like a path and it points to something |
| that exists, assume it is needed for remote execution. |
| """ |
| for e in self._rust_action.env: |
| key, sep, value = e.partition("=") |
| if sep == "=": |
| try: |
| p = Path(value) |
| if _env_file_exists(p): |
| yield cl_utils.relpath(p, start=self.working_dir) |
| except ValueError: # value is not a Path, ignore it |
| pass |
| |
| def _remote_inputs(self) -> Iterable[Path]: |
| """Remote inputs are relative to current working dir.""" |
| yield self.value_verbose( |
| "top source", self._rust_action.direct_sources[0] |
| ) |
| |
| # Pass along response files without altering the original command. |
| yield from self._rust_action.response_files |
| |
| yield from self._local_depfile_inputs() |
| |
| yield from self._remote_compiler_inputs() |
| |
| yield from self._rust_stdlib_libunwind_inputs() |
| |
| # Indirect dependencies (libraries) |
| yield from self.yield_verbose( |
| "extern libs", self._rust_action.extern_paths() |
| ) |
| |
| # Prefer to have the build system's command specify additional |
| # --remote-inputs instead of trying to infer them. |
| # yield from self.yield_verbose('env var files', self._inputs_from_env()) |
| |
| # Link arguments like static libs are checked for existence |
| # but not necessarily used until linking a binary. |
| # This is why we need to includes link_arg_files unconditionally, |
| # whereas the linker tools themselves can be dropped until linking binaries. |
| yield from self.yield_verbose( |
| "link arg files", self._rust_action.link_arg_files |
| ) |
| |
| if self.needs_linker: |
| yield from self._remote_linker_inputs() |
| |
| yield from self.yield_verbose( |
| "forwarded inputs", |
| _flatten_comma_list_to_paths(self._main_args.inputs), |
| ) |
| |
| def _remote_output_files(self) -> Iterable[Path]: |
| """Remote output files are relative to current working dir.""" |
| yield self.value_verbose("main output", self.primary_output) |
| |
| depfile = self.depfile |
| if depfile: |
| yield self.value_verbose("depfile", depfile) |
| |
| yield from self.yield_verbose( |
| "extra compiler outputs", self._rust_action.extra_output_files() |
| ) |
| |
| yield from self.yield_verbose( |
| "forwarded output files", |
| _flatten_comma_list_to_paths(self._main_args.output_files), |
| ) |
| |
| def _remote_output_dirs(self) -> Iterable[Path]: |
| yield from self.yield_verbose( |
| "forwarded output dirs", |
| _flatten_comma_list_to_paths(self._main_args.output_directories), |
| ) |
| |
| @property |
| def remote_options(self) -> Sequence[str]: |
| """rewrapper remote execution options.""" |
| fixed_remote_options = [ |
| # type=tool says we are providing a custom tool (Rust compiler), and |
| # thus, own the logic for providing explicit inputs. |
| # shallow=true works around an issue where racing mode downloads |
| # incorrectly |
| # toolname=rustc just helps classify the remote action type |
| "--labels=type=tool,shallow=true,toolname=rustc", |
| # --canonicalize_working_dir: coerce the output dir to a constant. |
| # This requires that the command be insensitive to output dir, and |
| # that its outputs do not leak the remote output dir. |
| # Ensuring that the results reproduce consistently across different |
| # build directories helps with caching. |
| "--canonicalize_working_dir=true", |
| ] |
| |
| # _main_remote_options should be allowed to override the |
| # fixed_remote_options |
| return fixed_remote_options + self._main_remote_options |
| |
| def prepare(self) -> int: |
| """Setup the remote action, but do not execute it. |
| |
| Returns: |
| exit code, 0 for success |
| """ |
| # cache the preparation |
| if self._prepare_status is not None: |
| return self._prepare_status |
| |
| # inputs and outputs are relative to current working dir |
| try: |
| remote_inputs = list(self._remote_inputs()) |
| except RemoteInputProcessingError as e: |
| msg(e) |
| return 1 |
| |
| remote_output_files = list(self._remote_output_files()) |
| remote_output_dirs = list(self._remote_output_dirs()) |
| |
| # Interpret --download_outputs=false as a request to avoid |
| # downloading only the primary rustc output (often the largest |
| # artifact). In other words, always download *all* other outputs, |
| # including the depfile and emitted llvm-ir (if applicable). |
| # The depfile *must* be downloaded because it is consumed by ninja. |
| |
| translated_remote_options = [] |
| for opt in self.remote_options: |
| if opt == "--download_outputs=false": |
| translated_remote_options.append( |
| f"--download_regex=-{self.primary_output}$" |
| ) |
| else: |
| translated_remote_options.append(opt) |
| |
| self._remote_action = remote_action.remote_action_from_args( |
| main_args=self._main_args, |
| remote_options=translated_remote_options, |
| command=list(self.remote_compile_command()), |
| inputs=remote_inputs, |
| output_files=remote_output_files, |
| output_dirs=remote_output_dirs, |
| working_dir=self.working_dir, |
| exec_root=self.exec_root, |
| post_remote_run_success_action=self._post_remote_success_action, |
| ) |
| self._prepare_status = 0 # exit code success |
| return self._prepare_status |
| |
| @property |
| def remote_action(self) -> remote_action.RemoteAction: |
| return self._remote_action |
| |
| @property |
| def remote_linker(self) -> Optional[Path]: |
| if not self.linker: |
| return None |
| return fuchsia.remote_executable(self.linker) |
| |
| @property |
| def target_linker_prefix(self) -> Optional[str]: |
| if not self.target: |
| return None |
| if "darwin" in self.target: |
| return "ld64" |
| return "ld" # most cases |
| |
| @property |
| def remote_ld_path(self) -> Optional[Path]: |
| ld = self._rust_action.use_ld # e.g. "lld" |
| if not ld: |
| return None |
| prefix = self.target_linker_prefix |
| if not prefix: |
| return None |
| return self.remote_linker.parent / f"{prefix}.{ld}" |
| |
| def _remote_linker_executables(self) -> Iterable[Path]: |
| if self.linker: |
| remote_linker = self.remote_linker |
| yield self.value_verbose("remote linker", remote_linker) |
| |
| # ld.lld -> lld, but the symlink is required for the clang |
| # linker driver to be able to use lld. |
| # Nowadays, lld -> llvm. |
| # ld.LINKER is expected to be in the remote environment PATH. |
| # See ToolChain::GetLinkerPath() in llvm-project:clang/lib/Driver/ToolChain.cpp |
| ld = self._rust_action.use_ld # e.g. "lld" |
| if ld: |
| yield self.value_verbose( |
| "remote clang -fuse-ld", self.remote_ld_path |
| ) |
| |
| def _remote_libcxx(self, clang_lib_triple: str) -> Iterable[Path]: |
| if self.clang_cxx_stdlibdir: # override, selecting for variant |
| libcxx_remote = self.clang_cxx_stdlibdir / "libc++.a" |
| else: |
| libcxx_remote = fuchsia.clang_libcxx_static( |
| self.remote_clang_toolchain_dir, clang_lib_triple |
| ) |
| if _libcxx_isfile(libcxx_remote): |
| yield self.value_verbose("remote libc++", libcxx_remote) |
| |
| def _remote_clang_runtime_libs( |
| self, clang_lib_triple: str |
| ) -> Iterable[Path]: |
| # clang runtime lib dir |
| rt_libdir_remote = list( |
| fuchsia.clang_runtime_libdirs( |
| self.remote_clang_toolchain_dir, clang_lib_triple |
| ) |
| ) |
| # if none found, that's ok. |
| if len(rt_libdir_remote) == 1: |
| yield self.value_verbose( |
| "remote runtime libdir", rt_libdir_remote[0] |
| ) |
| if len(rt_libdir_remote) > 1: |
| raise RemoteInputProcessingError( |
| f"Found more than one clang runtime lib dir (don't know which one to use): {rt_libdir_remote}" |
| ) |
| |
| def _c_sysroot_files(self) -> Iterable[Path]: |
| # sysroot files |
| if not self.target: |
| return |
| c_sysroot_dir = self.c_sysroot |
| if not c_sysroot_dir: |
| return |
| # if sysroot points outside of exec_root, stop |
| if self._c_sysroot_is_outside_exec_root: |
| return |
| sysroot_triple = fuchsia.rustc_target_to_sysroot_triple(self.target) |
| if c_sysroot_dir: |
| # Some sysroot files are linker scripts to be expanded. |
| if sysroot_triple: |
| search_paths = [ |
| c_sysroot_dir / "usr/lib" / sysroot_triple, |
| c_sysroot_dir / "lib" / sysroot_triple, |
| ] |
| else: |
| search_paths = [c_sysroot_dir / "lib"] |
| |
| link = linker.LinkerInvocation( |
| working_dir_abs=self.working_dir, search_paths=search_paths |
| ) |
| |
| lld = self.host_compiler.parent / "ld.lld" # co-located with clang |
| |
| def linker_script_expander(paths: Sequence[Path]) -> Iterable[Path]: |
| if lld.exists(): |
| yield from link.expand_using_lld(lld=lld, inputs=paths) |
| else: |
| for path in paths: |
| yield from link.expand_possible_linker_script(path) |
| |
| yield from self.yield_verbose( |
| "C sysroot files", |
| fuchsia.c_sysroot_files( |
| sysroot_dir=c_sysroot_dir, |
| sysroot_triple=sysroot_triple, |
| with_libgcc=self._rust_action.want_sysroot_libgcc, |
| linker_script_expander=linker_script_expander, |
| ), |
| ) |
| |
| def _remote_linker_inputs(self) -> Iterable[Path]: |
| if self.linker: |
| yield from self._remote_linker_executables() |
| |
| if self.target: |
| clang_lib_triple = fuchsia.rustc_target_to_clang_target( |
| self.target |
| ) |
| yield from self._remote_libcxx(clang_lib_triple) |
| yield from self._remote_clang_runtime_libs(clang_lib_triple) |
| |
| # --crate-type cdylib needs rust-lld (hard-coding this is a hack) |
| # This will always be linux-x64, even when cross-compiling, because |
| # that is the only RBE remote backend option available. |
| if self.crate_type == rustc.CrateType.CDYLIB: |
| yield self.value_verbose( |
| "remote rust-lld", |
| fuchsia.remote_rustc_to_rust_lld_path(self.remote_compiler), |
| ) |
| |
| yield from self._c_sysroot_files() |
| |
| def _depfile_exists(self) -> bool: |
| # Defined for easy mocking. |
| return self.depfile and self.depfile.exists() |
| |
| def _post_remote_success_action(self) -> int: |
| if self._depfile_exists(): |
| self._rewrite_remote_or_local_depfile() |
| |
| if ( |
| self.remote_action.skipping_some_download |
| and self._rust_action.main_output_is_executable |
| ): |
| # TODO(b/285030257): This is a workaround to a problem where |
| # download stubs need the appropriate execution permissions |
| # to be set, so that remote execution inputs get the same |
| # permissions. This is important for tools that mirror execution |
| # bits from inputs to outputs, like llvm-objcopy. |
| # Once re-client presents permission information in the |
| # --action_log (reproxy remote_metadata), this workaround can |
| # be replaced with a more generalized solution. |
| if remote_action.is_download_stub_file(self.primary_output): |
| self.primary_output.chmod(_EXEC_PERMS) |
| return 0 |
| |
| def _rewrite_remote_or_local_depfile(self): |
| """Rewrite depfile without working dir absolute paths. |
| |
| TEMPORARY WORKAROUND until upstream fix lands: |
| https://github.com/pest-parser/pest/pull/522 |
| Rewrite the depfile if it contains any absolute paths from the remote |
| build; paths should be relative to the root_build_dir. |
| |
| Assume that the output dir is two levels down from the exec_root. |
| |
| When using the `canonicalize_working_dir` rewrapper option, |
| the output directory is coerced to a predictable 'set_by_reclient' constant. |
| See https://source.corp.google.com/foundry-x-re-client/internal/pkg/reproxy/action.go;l=131 |
| It is still possible for a tool to leak absolute paths, which could |
| expose that constant in returned artifacts. |
| We forgive this for depfiles, but other artifacts should be verified |
| separately. |
| """ |
| # It is possible for this to run after local execution with |
| # exec_strategy=local,racing,remote_local_fallback, so the logic |
| # herein should accommodate both possibilities. |
| # In the future, it might be possible to determine whether the local |
| # or remote result was used from self.action_log. |
| self.vmsg(f"Rewriting the (remote or local) depfile {self.depfile}") |
| remote_action.rewrite_depfile( |
| dep_file=self.working_dir / self.depfile, # in-place |
| transform=self.remote_action._relativize_remote_or_local_deps, |
| ) |
| |
| def run_remote(self) -> int: |
| prepare_status = self.prepare() |
| if prepare_status != 0: |
| return prepare_status |
| |
| try: |
| return self.remote_action.run_with_main_args(self._main_args) |
| |
| finally: |
| self._cleanup() |
| |
| def run_local(self) -> int: |
| # Even if this is running locally, some of intermediate inputs |
| # have have come from remote actions that opted not to |
| # download their outputs (and left only download stubs). |
| # To be safe, verify the inputs and download as needed. |
| |
| prepare_status = self.prepare() |
| if prepare_status != 0: |
| return prepare_status |
| |
| # We know in our build system configuration that the following |
| # file suffixes could have come from remote builds. |
| # It is ok for this set to be conservatively inclusive. |
| # Eliminate inputs that come from the project root ../.., |
| # because those are sources or prebuilts. |
| remote_artifact_suffixes = {".o", ".a", ".so", ".dylib", ".rlib"} |
| download_statuses = self.remote_action.download_inputs( |
| lambda path: path.suffix in remote_artifact_suffixes |
| and not str(path).startswith(str(self.remote_action.exec_root_rel)) |
| ) |
| for path, status in download_statuses.items(): |
| if status.returncode != 0: |
| msg(f"Failed to download input: {path}\n{status.stderr_text}") |
| return status.returncode |
| |
| # don't bother with remote action preparation |
| # or any of the remote action features. |
| export_dir = self.miscomparison_export_dir |
| command = cl_utils.auto_env_prefix_command( |
| _filter_local_command(self.original_command) |
| ) |
| if self.check_determinism: |
| self.vmsg("Comparing two local runs of the original command.") |
| |
| output_files = list(self._remote_output_files()) |
| |
| max_attempts = self.determinism_attempts |
| # For b/328756843, increase repetition count for hard-to-reproduce cases. |
| override_attempts = fuchsia.determinism_repetitions(output_files) |
| if override_attempts is not None: |
| msg( |
| f"Notice: Overriding number of determinism repetitions: {override_attempts}" |
| ) |
| max_attempts = override_attempts |
| |
| command = fuchsia.check_determinism_command( |
| exec_root=self.exec_root_rel, |
| outputs=output_files, |
| command=command, |
| max_attempts=max_attempts, |
| miscomparison_export_dir=( |
| export_dir / self.build_subdir if export_dir else None |
| ), |
| label=self.label, |
| ) |
| |
| exit_code = subprocess.call(command, cwd=self.working_dir) |
| |
| # Optional: on determinism failures, copy data. |
| if exit_code != 0 and self.check_determinism and export_dir: |
| # Compute the inputs that would have been used for remote execution |
| if not self.remote_action: |
| self.prepare() |
| # Check determinism script already copies outputs, we just copy the inputs. |
| with cl_utils.chdir_cm(self.exec_root): |
| for f in self.remote_action.inputs_relative_to_project_root: |
| cl_utils.copy_preserve_subpath(f, export_dir) |
| |
| return exit_code |
| |
| def run(self) -> int: |
| if self.local_only: |
| return self.run_local() |
| else: |
| return self.run_remote() |
| |
| |
| def main(argv: Sequence[str]) -> int: |
| rust_remote_action = RustRemoteAction( |
| argv, # [remote options] -- rustc-compile-command... |
| exec_root=remote_action.PROJECT_ROOT, |
| working_dir=Path(os.curdir), |
| host_platform=fuchsia.HOST_PREBUILT_PLATFORM, |
| ) |
| return rust_remote_action.run() |
| |
| |
| if __name__ == "__main__": |
| sys.exit(main(sys.argv[1:])) |
