| # Copyright 2017 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. |
| """Recipe for building Rust toolchain.""" |
| |
| from recipe_engine.config import Enum |
| from recipe_engine.recipe_api import Property |
| |
| import re |
| |
| DEPS = [ |
| "fuchsia/buildbucket_util", |
| "fuchsia/cipd_platform", |
| "fuchsia/git", |
| "fuchsia/goma", |
| "fuchsia/macos_sdk", |
| "fuchsia/nullcontext", |
| "fuchsia/status_check", |
| "fuchsia/toolchain", |
| "fuchsia/upload", |
| "recipe_engine/cipd", |
| "recipe_engine/context", |
| "recipe_engine/file", |
| "recipe_engine/json", |
| "recipe_engine/path", |
| "recipe_engine/platform", |
| "recipe_engine/properties", |
| "recipe_engine/python", |
| "recipe_engine/raw_io", |
| "recipe_engine/step", |
| ] |
| |
| PACKAGES = ["rust", "rust_tools"] |
| |
| PROPERTIES = { |
| "repository": Property( |
| kind=str, |
| help="Git repository URL", |
| default="https://fuchsia.googlesource.com/third_party/rust", |
| ), |
| "branch": Property(kind=str, help="Git branch", default="refs/heads/master"), |
| "revision": Property(kind=str, help="Revision", default=None), |
| "package": Property( |
| kind=Enum(*PACKAGES), help="Which package to build", default="rust" |
| ), |
| } |
| |
| |
| def RunSteps(api, repository, branch, revision, package): |
| use_goma = ( |
| not api.platform.arch == "arm" and api.platform.bits == 64 |
| ) and not api.platform.is_win |
| if use_goma: |
| api.goma.ensure() |
| goma_context = api.goma.build_with_goma |
| else: |
| goma_context = api.nullcontext |
| |
| if not revision: |
| revision = api.git.get_remote_branch_head(repository, branch) |
| |
| host_platform = api.cipd_platform.name |
| |
| use_breakpad = host_platform == "linux-amd64" |
| |
| with api.step.nest("ensure_packages"): |
| with api.context(infra_steps=True): |
| pkgs = api.cipd.EnsureFile() |
| pkgs.add_package("infra/3pp/tools/cmake/${platform}", "version:3.13.5") |
| pkgs.add_package("infra/3pp/tools/ninja/${platform}", "version:1.9.0") |
| pkgs.add_package("infra/3pp/tools/swig/${platform}", "version:4.0.2") |
| pkgs.add_package("fuchsia/third_party/clang/${platform}", "integration") |
| pkgs.add_package("fuchsia/sysroot/linux-amd64", "latest", "linux-amd64") |
| pkgs.add_package("fuchsia/sysroot/linux-arm64", "latest", "linux-arm64") |
| # We don't have SDK for linux-arm64 or win, but we only need sysroot. |
| if ( |
| api.platform.arch == "arm" and api.platform.bits == 64 |
| ) or api.platform.is_win: |
| pkgs.add_package("fuchsia/sdk/core/linux-amd64", "latest", "sdk") |
| else: |
| pkgs.add_package("fuchsia/sdk/core/${platform}", "latest", "sdk") |
| if use_breakpad: |
| pkgs.add_package( |
| "fuchsia/tools/breakpad/${platform}", "latest", "breakpad" |
| ) |
| cipd_dir = api.path["start_dir"].join("cipd") |
| api.cipd.ensure(cipd_dir, pkgs) |
| sdk_dir = cipd_dir.join("sdk") |
| |
| with api.context(infra_steps=True): |
| rust_dir = api.path["start_dir"].join("rust") |
| api.git.checkout(repository, rust_dir, ref=revision, recursive=True) |
| |
| # build rust |
| staging_dir = api.path["start_dir"].join("staging") |
| build_dir = staging_dir.join("build") |
| api.file.ensure_directory("build", build_dir) |
| pkg_dir = staging_dir.join("rust") |
| api.file.ensure_directory("create pkg_dir", pkg_dir) |
| |
| with api.macos_sdk(), goma_context(): |
| if api.platform.name == "linux": |
| host_sysroot = cipd_dir.join(host_platform) |
| elif api.platform.name == "mac": |
| # TODO(fxbug.dev/3043): Eventually use our own hermetic sysroot as for Linux. |
| step_result = api.step( |
| "xcrun", |
| ["xcrun", "--sdk", "macosx", "--show-sdk-path"], |
| stdout=api.raw_io.output(name="sdk-path", add_output_log=True), |
| step_test_data=lambda: api.raw_io.test_api.stream_output( |
| "/some/xcode/path" |
| ), |
| ) |
| host_sysroot = step_result.stdout.strip() |
| else: # pragma: no cover |
| assert False, "unsupported platform" |
| |
| targets = [ |
| "x86_64-unknown-linux-gnu", |
| "aarch64-unknown-linux-gnu", |
| "wasm32-unknown-unknown", |
| ] |
| if api.platform.is_mac: |
| targets.append("x86_64-apple-darwin") |
| |
| config_file = "config.toml" |
| api.python( |
| "generate config.toml", |
| api.resource("generate_config.py"), |
| args=[ |
| "config_toml", |
| "--targets", |
| ",".join(targets), |
| "--clang-prefix", |
| cipd_dir, |
| "--prefix", |
| pkg_dir, |
| "--host-sysroot", |
| host_sysroot, |
| ] |
| + (["--goma-dir", api.goma.goma_dir] if use_goma else []) |
| + (["--extra-tools-only"] if package == "rust_tools" else []), |
| stdout=api.raw_io.output(leak_to=build_dir.join(config_file)), |
| ) |
| |
| env_data = api.python( |
| "generate environment", |
| api.resource("generate_config.py"), |
| args=[ |
| "environment", |
| "--targets", |
| ",".join(targets), |
| "--clang-prefix", |
| cipd_dir, |
| "--sdk-dir", |
| sdk_dir, |
| "--revision", |
| revision, |
| # TODO(tmandry): Switch to multiarch so these don't need to be separate |
| "--linux-amd64-sysroot", |
| cipd_dir.join("linux-amd64"), |
| "--linux-arm64-sysroot", |
| cipd_dir.join("linux-arm64"), |
| ] |
| + (["--darwin-sysroot", host_sysroot] if api.platform.is_mac else []), |
| stdout=api.raw_io.output(name="environment", add_output_log=True), |
| step_test_data=lambda: api.raw_io.test_api.stream_output( |
| "RUST_BACKTRACE=1" |
| ), |
| ) |
| env = {} |
| for line in env_data.stdout.splitlines(): |
| key, value = line.split("=", 1) |
| env[key] = value |
| |
| env_prefixes = {"PATH": [cipd_dir, cipd_dir.join("bin")]} |
| with api.context(cwd=build_dir, env=env, env_prefixes=env_prefixes): |
| api.python( |
| "rust install", |
| rust_dir.join("x.py"), |
| args=["install", "--config", config_file], |
| ) |
| |
| runtime_result = api.python( |
| "generate runtime spec", |
| api.resource("generate_config.py"), |
| args=["runtime"], |
| stdout=api.json.output(), |
| ) |
| api.toolchain.strip_runtimes( |
| name="generate runtime.json", |
| spec=runtime_result.stdout, |
| path=pkg_dir.join("lib"), |
| build_id_subpath="debug/.build-id", |
| readelf=cipd_dir.join("bin", "llvm-readelf"), |
| objcopy=cipd_dir.join("bin", "llvm-objcopy"), |
| dump_syms=( |
| cipd_dir.join("breakpad", "dump_syms", "dump_syms") |
| if use_breakpad |
| else None |
| ), |
| ) |
| |
| isolated = api.upload.upload_isolated(pkg_dir) |
| |
| # package rust |
| step_result = api.step( |
| "rust version", |
| [pkg_dir.join("bin", "rustc"), "--version"], |
| stdout=api.raw_io.output(), |
| step_test_data=lambda: api.raw_io.test_api.stream_output( |
| "rustc 1.19.0-nightly (75b056812 2017-05-15)" |
| ), |
| ) |
| m = re.search(r"rustc ([0-9a-z.-]+)", step_result.stdout) |
| assert m, "Cannot determine Rust version" |
| version = m.group(1) |
| |
| if not api.buildbucket_util.is_tryjob: |
| api.upload.cipd_package( |
| "fuchsia/third_party/%s/${platform}" % package, |
| pkg_dir, |
| [api.upload.DirectoryPath(pkg_dir)], |
| {"git_revision": revision}, |
| repository=repository, |
| extra_tags={"version": version}, |
| ) |
| |
| builders = { |
| "linux-amd64": ( |
| "rust_toolchain.fuchsia-arm64-debug", |
| "rust_toolchain.fuchsia-arm64-release", |
| "rust_toolchain.fuchsia-x64-debug", |
| "rust_toolchain.fuchsia-x64-release", |
| ), |
| "mac-amd64": ("rust_toolchain.fuchsia-host-mac",), |
| } |
| if package == "rust" and host_platform in builders: |
| # Do a full integration build. This will use the just-built toolchain |
| # to build all of Fuchsia to check whether there are any regressions. |
| api.toolchain.trigger_build( |
| "rust_toolchain", |
| repository, |
| revision, |
| isolated, |
| builders=builders[host_platform], |
| ) |
| |
| |
| def GenTests(api): |
| revision = "75b05681239cb309a23fcb4f8864f177e5aa62da" |
| for platform in ("linux", "mac"): |
| for package in ("rust", "rust_tools"): |
| for arch in ("intel", "arm") if platform == "linux" else ("intel",): |
| yield ( |
| api.status_check.test("%s_%s_%s" % (package, arch, platform)) |
| + api.platform.name(platform) |
| + api.platform.arch(arch) |
| + api.properties(package=package) |
| + api.git.get_remote_branch_head("git ls-remote", revision) |
| + api.step_data("generate runtime spec", stdout=api.json.output([])) |
| ) |
| yield ( |
| api.status_check.test("%s_%s_%s_new" % (package, arch, platform)) |
| + api.platform.name(platform) |
| + api.platform.arch(arch) |
| + api.properties(package=package) |
| + api.git.get_remote_branch_head("git ls-remote", revision) |
| + api.step_data("generate runtime spec", stdout=api.json.output([])) |
| + api.step_data( |
| "cipd.cipd search fuchsia/third_party/%s/${platform} " % package |
| + "git_revision:" |
| + revision, |
| api.json.output({"result": []}), |
| ) |
| ) |
