| #!/bin/bash |
| # Copyright 2019 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. |
| |
| #### CATEGORY=Build |
| ### set up a build directory |
| |
| ## usage: fx set PRODUCT.BOARD [--with GNLABEL1,GNLABEL2,...] |
| ## [--release] [--auto-dir] [--args ARG] [--variant VARIANT] |
| ## [--with-base GNLABEL1,GNLABEL2,...] |
| ## |
| ## where PRODUCT is an entry from `//products` or `//vendor/*/products` and |
| ## BOARD is an entry from `//boards` or `//vendor/*/boards`. Use the |
| ## `fx list-products` and `fx list-boards` commands to see a list of |
| ## possible products and boards (respectively). See the README.md in those |
| ## directories for a description of the various options. |
| ## |
| ## BUILDDIR is the directory where the build output goes. |
| ## If it begins with `//` or `out/` then it's taken as relative to FUCHSIA_DIR. |
| ## Otherwise it should be an absolute path or a path relative to the current |
| ## working directory that winds up in `FUCHSIA_DIR/out`. |
| ## It defaults to `out/default`. |
| ## |
| ## This command stores the location of the build directory in the //.fx-build-dir |
| ## file, which causes subsequent `fx` commands to use that build directory. Use |
| ## `fx use` to switch build directories. |
| ## |
| ## Ensures Goma is ready (if Goma is enabled). |
| ## |
| ## This is a wrapper around running `gn gen --check=system BUILDDIR --args ...`. |
| ## If GN fails with an error, `fx set` does not change anything. |
| ## |
| ## optional arguments: |
| ## --args Additional argument to pass to gn. If the --args |
| ## argument is given multiple times, all the specified |
| ## arguments are passed to gn. |
| ## N.B. Arguments must be expressed using GN's syntax. |
| ## In particular this means that for strings they must |
| ## be quoted with double-quotes, and the quoting must |
| ## survive, for example, the shell. Thus when passing |
| ## an argument that takes a string, pass it with |
| ## something like --args=foo='"bar"'. E.g., |
| ## bash$ fx set core.x64 --args=foo='"bar"' |
| ## More complicated arguments, e.g., lists, require |
| ## their own special syntax. See GN documentation |
| ## for the syntax of each kind of argument. |
| ## --auto-dir Act like `fx --dir out/PRODUCT.BOARD set ...`. |
| ## --ccache|--no-ccache Whether to use ccache during the build. Ccache attempts |
| ## to make builds faster by caching build artifacts. |
| ## Defaults to detecting whether the CCACHE_DIR environment |
| ## variable is set to a directory. |
| ## --fuzz-with Pass a sanitizer name, e.g. "--fuzz-with asan" to |
| ## enable ALL supporting fuzzers. Use --variant for |
| ## individual fuzzers, e.g. "--variant asan-fuzzer/foo". |
| ## --goma|--no-goma Whether to use the goma service during the build. Goma |
| ## attempts to make builds faster using remote build |
| ## servers. Defaults to detecting whether goma has been |
| ## set up via `fx goma`. |
| ## --ide Pass --ide=VALUE to gn when generating to create project |
| ## files usable with that IDE. Useful values include "vs" |
| ## for Visual Studio or "xcode" for Xcode. |
| ## --json-ide-script Pass --json-ide-script=python_script to gn which runs |
| ## the given python script after the JSON project file is |
| ## generated when using --ide json. The path to the project |
| ## file is given as the first argument to the script. |
| ## The script may be a path or a gn label. |
| ## --netboot Ensure that a network ramboot image is always built. |
| ## --no-ensure-goma Skip ensuring that goma is started when using goma. |
| ## --release an alias for "--args=is_debug=false" |
| ## --variant Selects which runtime variant to use (e.g., asan) by |
| ## passing a `select_variant=[VARIANT*,...]` argument |
| ## to gn that collects all the --variant arguments in |
| ## order. Variants are normal builds in most respects, |
| ## but allow users to test different runtime settings |
| ## for either the whole build or for a specific target. |
| ## This can be specified by passing the variant name |
| ## to this argument (e.g. `--variant asan`) for the |
| ## former, or the variant name and the target name |
| ## separated by a slash (e.g. `--variant asan/my_test`) |
| ## for the latter. |
| ## --with GNLABEL Labels of additional packages to include in the |
| ## 'universe' set of available packages. These packages |
| ## can be run ephemerally. Multiple labels can be |
| ## provided delimited by commas or the --with argument |
| ## can be provided multiple times. |
| ## --with-base GNLABEL Labels of additional packages to include in the |
| ## 'base' set of packages. These packages are included in |
| ## the system image and can be updated only with an OTA. |
| ## Multiple labels can be provided delimited by commas |
| ## or the --with-base argument can be provided multiple |
| ## times. |
| ## --with-cache GNLABEL Labels of additional packages to include in the |
| ## 'cache' set of packages. These packages are made |
| ## available on disk immediately after paving and in |
| ## factory flows. These packages are not updated with |
| ## an OTA, but are instead updated ephemerally. This |
| ## cache of software can be evicted by the system if |
| ## storage pressure arises or other policies indicate. |
| ## Multiple labels can be provided delimited by commas |
| ## or the --with-cache argument can be provided |
| ## multiple times. |
| ## --with-host GNLABEL Labels of additional host-only targets to be |
| ## produced by the build. Multiple labels can be |
| ## provided delimited by commas or the --with-host |
| ## argument can be provided multiple times. |
| ## --cargo-toml-gen Enable generation of Cargo.toml files |
| ## --dev Always recompile fx-set from source. Ignored unless |
| ## the legacy_set feature is disabled. |
| ## |
| ## Example: |
| ## |
| ## $ fx set core.x64 --with //bundles:tests |
| ## -> build directory: out/default |
| ## board: //boards/x64.gni |
| ## product: //products/core.gni |
| ## universe: //bundles:tests (all test packages) |
| |
| source "$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"/lib/vars.sh || exit $? |
| |
| set -e |
| |
| function find_config { |
| local config_type="$1" |
| local config_name="$2" |
| |
| for directory in vendor/*/"${config_type}" "${config_type}"; do |
| local guessed_config="${directory}/${config_name}.gni" |
| if [[ -a "${guessed_config}" ]]; then |
| echo "${guessed_config}" |
| return |
| fi |
| done |
| |
| fx-error "Could not find a ${config_type} configuration matching \"${config_name}\"" |
| fx-error "Checked:" |
| for directory in vendor/*/"${config_type}" "${config_type}"; do |
| local guessed_config="${directory}/${config_name}.gni" |
| fx-error " ${guessed_config}" |
| done |
| exit 1 |
| } |
| |
| function explain-goal-argument { |
| fx-error You must specify which product and which board you wish to build. |
| fx-error Example: |
| fx-error " fx set core.x64" |
| fx-error |
| fx-error Run \"fx list-products\" to see the available products. |
| fx-error Run \"fx list-boards\" to see the available boards. |
| fx-error Run \"fx set --help\" to see full usage. |
| fx-error Run \"fx status\" to see the current developer settings. |
| return 0 |
| } |
| |
| function main { |
| fx-standard-switches "$@" |
| set -- "${FX_ARGV[@]}" |
| |
| # Check if the --dev flag is set. If it is, then we'll always build fx-set |
| # from source. |
| local dev=false |
| for arg; do |
| shift |
| if [ "$arg" = --dev ]; then |
| dev=true |
| continue |
| fi |
| # Include every arg besides --dev in the args we pass to fx-set. |
| set -- "$@" "$arg" |
| done |
| |
| if ! is_feature_enabled "legacy_set"; then |
| # Cache the compiled executable for later invocations. |
| readonly exe_path="${FX_CACHE_DIR}/fx-set" |
| |
| readonly revision_file="${FX_CACHE_DIR}/fx-set-revision" |
| local current_revision |
| current_revision="$(git -C "$FUCHSIA_DIR" rev-parse HEAD)" |
| |
| # Determine whether we need to rebuild the fx-set executable. We'll only |
| # rebuild if the --dev flag is set, or if the cached version of fx-set was |
| # built at a revision other than the current revision. We determine that by |
| # storing the current HEAD of fuchsia.git in a cached version file whenever |
| # we build fx-set, and then we rebuild if the current HEAD differs from the |
| # revision referenced in the cached file. |
| local should_rebuild=true |
| if ! $dev && [ -f "$exe_path" ] && [ -f "$revision_file" ]; then |
| local fx_set_revision |
| fx_set_revision="$(head -n 1 "$revision_file")" |
| if [ "$fx_set_revision" = "$current_revision" ]; then |
| should_rebuild=false |
| fi |
| fi |
| |
| if $should_rebuild; then |
| # It may take upwards of 3 seconds to build the tool depending on the |
| # state of the system's Go build cache. Add a temporary log so the user |
| # knows what's going on (but only do it if stdout is terminal, since |
| # otherwise we won't be able to clear the log). |
| if [ -t 1 ]; then |
| fx-info "Compiling fx set..." |
| fi |
| |
| # Build in a temporary directory where we can arrange the module. |
| # |
| # Avoid "TMPDIR" since Go looks at that environment variable. |
| BUILD_DIR=$(mktemp -d) |
| trap 'rm -rf $BUILD_DIR' EXIT |
| pushd "$BUILD_DIR" > /dev/null |
| for target in go.{mod,sum} vendor; do |
| ln -s "$FUCHSIA_DIR"/third_party/golibs/$target . |
| done |
| ln -s "$FUCHSIA_DIR"/tools . |
| GOPROXY=off fx-command-run go build -o "$exe_path" ./tools/build/fx-set/cmd |
| popd > /dev/null |
| |
| if [ -t 1 ]; then |
| # Delete the "compiling fx set" log so it doesn't show up in the final |
| # output. |
| echo -n -e "\r\033[1A\033[0K" |
| fi |
| |
| # Record the current HEAD *after* building fx-set so that we always try |
| # to rebuild on subsequent attempts if compilation fails the first time. |
| echo "$current_revision" > "$revision_file" |
| fi |
| |
| exec "$exe_path" "$@" |
| fi |
| |
| if [[ $# -lt 1 ]]; then |
| fx-error Missing an explicit PRODUCT.BOARD goal. |
| explain-goal-argument |
| return 1 |
| fi |
| |
| cd "${FUCHSIA_DIR}" |
| |
| local gn_args="" |
| case "$1" in |
| *.*) |
| local product_name="${1%.*}" |
| local board_name="${1##*.}" |
| local product board |
| product="$(find_config "products" "${product_name}")" |
| board="$(find_config "boards" "${board_name}")" |
| if [[ "${product}" == "" ]] || [[ "${board}" == "" ]]; then |
| exit 1 |
| fi |
| gn_args+=" import(\"//${board}\") import(\"//${product}\")" |
| gn_args+=" build_info_board=\"${board_name}\" build_info_product=\"${product_name}\"" |
| ;; |
| *) |
| fx-error "Unable to parse PRODUCT.BOARD goal \"$1\"" |
| explain-goal-argument |
| return 1 |
| ;; |
| esac |
| shift |
| |
| local gn_cmd='gen' |
| local -a gn_switches=(--fail-on-unused-args --check=system --export-rust-project --export-compile-commands=default --ninja-executable="${PREBUILT_NINJA}") |
| local gn_after_args="" |
| local base_packages=() |
| local cache_packages=() |
| local universe_packages=() |
| local host_labels=() |
| local auto_dir_variants= |
| local auto_dir=false |
| local is_release=false |
| local build_dir= |
| local variant= |
| local use_goma |
| local goma_dir |
| local ensure_goma=1 |
| local cargo_toml_gen=0 |
| local ccache |
| while [[ $# -ne 0 ]]; do |
| case "$1" in |
| --auto-dir) |
| if [[ -n "${_FX_BUILD_DIR}" ]]; then |
| fx-error "fx --dir and fx set --auto-dir are mutually exclusive, pick one." |
| return 1 |
| fi |
| auto_dir=true |
| ;; |
| --with-base) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| IFS="," read -r -a labels <<< "$2" |
| base_packages+=("${labels[@]}") |
| shift |
| ;; |
| --with-cache) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| IFS="," read -r -a labels <<< "$2" |
| cache_packages+=("${labels[@]}") |
| shift |
| ;; |
| --with) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| IFS="," read -r -a labels <<< "$2" |
| universe_packages+=("${labels[@]}") |
| shift |
| ;; |
| --with-host) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| IFS="," read -r -a labels <<< "$2" |
| host_labels+=("${labels[@]}") |
| shift |
| ;; |
| --cargo-toml-gen) |
| cargo_toml_gen=1 |
| ;; |
| --netboot) |
| gn_after_args+=" enable_netboot=true" |
| ;; |
| --goma) |
| use_goma=1 |
| ;; |
| --no-goma) |
| use_goma=0 |
| ;; |
| --no-ensure-goma) |
| ensure_goma=0 |
| ;; |
| --goma-dir) |
| # TODO(haowei): Remove it once no other script use it. |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| goma_dir=$2 |
| if [[ ! -d "${goma_dir}" ]]; then |
| fx-error "GOMA directory does not exist: ${goma_dir}" |
| return 1 |
| fi |
| use_goma=1 |
| shift |
| ;; |
| --build-dir) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| if [[ -n "${_FX_BUILD_DIR}" ]]; then |
| fx-error "fx --dir and fx set --build-dir are mutually exclusive, pick one." |
| return 1 |
| fi |
| fx-warn "DEPRECATED: \"fx set --build-dir DIR\"" |
| fx-warn " NEW: \"fx --dir DIR set\"" |
| build_dir="$2" |
| shift |
| ;; |
| --release) |
| gn_args+=" is_debug=false" |
| is_release=true |
| ;; |
| --variant) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| variant+="\"$2\"," |
| auto_dir_variants+="-$2" |
| shift |
| ;; |
| --fuzz-with) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| variant+="{variant=\"$2-fuzzer\" target_type=[\"fuzzed_executable\"]}," |
| # TODO(fxbug.dev/38226): Fuzzers need a version of libfdio.so that is sanitized, |
| # but doesn't collect coverage data. |
| variant+="{variant=\"$2\" label=[\"//sdk/lib/fdio\"]}," |
| shift |
| ;; |
| --args) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| gn_args+=" $2" |
| shift |
| ;; |
| --help-args) |
| gn_cmd=args |
| if [[ $# -ge 2 ]] && [[ "$2" != '--*' ]]; then |
| gn_switches+=("--list=$2") |
| shift |
| else |
| gn_switches+=(--list) |
| fi |
| fx-warn "DEPRECATED: \"fx set --help-args[=ARG]\"" |
| fx-warn " NEW: \"fx args [--list=ARG]\"" |
| ;; |
| --ccache) |
| ccache=1 |
| ;; |
| --no-ccache) |
| ccache=0 |
| ;; |
| --ide) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| gn_switches+=("--ide=$2") |
| shift |
| ;; |
| --json-ide-script) |
| if [[ $# -lt 2 ]]; then |
| fx-command-help |
| return 1 |
| fi |
| gn_switches+=("--json-ide-script=$2") |
| shift |
| ;; |
| *) |
| fx-error "Unknown argument \"$1\"" |
| fx-command-help |
| return 1 |
| ;; |
| esac |
| shift |
| done |
| |
| if [[ -z "${build_dir}" ]]; then |
| build_dir="${_FX_BUILD_DIR}" |
| fi |
| |
| # Remove any trailing slash from build directory name. |
| build_dir="${build_dir%/}" |
| |
| local config_build_dir |
| if $auto_dir; then |
| if [[ -n "$build_dir" ]]; then |
| fx-error "--auto-dir and --build-dir are mutually exclusive, pick one." |
| return 1 |
| fi |
| if [[ "$auto_dir_variants" == */* ]]; then |
| fx-error "--auto-dir only works with simple catch-all --variant switches; choose your own directory name with fx --dir for a complex configuration" |
| return 1 |
| fi |
| config_build_dir="out/${product_name}.${board_name}${auto_dir_variants}" |
| if $is_release; then |
| config_build_dir+="-release" |
| fi |
| else |
| case "$build_dir" in |
| '') |
| # Default is "//out/default". Store it as relative. |
| config_build_dir="out/default" |
| ;; |
| //*|out/*) |
| # GN-style "source-relative" path or relative out/something. |
| config_build_dir="${build_dir#//}" |
| ;; |
| *) |
| fx-error "Invalid build directory: ${build_dir}" |
| fx-error "Please specify a build directory as \"out/something\"." |
| exit 1 |
| ;; |
| esac |
| fi |
| build_dir="${FUCHSIA_DIR}/${config_build_dir}" |
| |
| # Automatically detect goma and ccache if not specified explicitly. |
| if [[ -z "${use_goma}" ]] && [[ -z "${ccache}" ]]; then |
| # Use Goma if --goma-dir was given or if the prebuilt Goma |
| # seems to have been setup. |
| if "$PREBUILT_PYTHON3_DIR/bin/python3" "$PREBUILT_GOMA_DIR/goma_auth.py" info > /dev/null 2>&1; then |
| use_goma=1 |
| elif [[ -n "${CCACHE_DIR}" ]] && [[ -d "${CCACHE_DIR}" ]]; then |
| ccache=1 |
| fi |
| elif [[ "${use_goma}" -eq 1 ]] && [[ "${ccache}" -eq 1 ]]; then |
| fx-error "--goma and --ccache are mutually exclusive, pick one." |
| return 1 |
| fi |
| |
| # Add goma or ccache settings as appropriate. |
| if [[ "${use_goma}" -eq 1 ]]; then |
| gn_args+=" use_goma=true" |
| else |
| gn_args+=" use_goma=false" |
| if [[ "${ccache}" -eq 1 ]]; then |
| gn_args+=" use_ccache=true" |
| fi |
| fi |
| |
| gn_args+=" |
| # See: fx args --list=base_package_labels |
| base_package_labels+=[" |
| |
| for package in "${base_packages[@]}"; do |
| gn_args+="\"${package}\"," |
| done |
| gn_args+="] |
| |
| # See: fx args --list=cache_package_labels |
| cache_package_labels+=[" |
| |
| for package in "${cache_packages[@]}"; do |
| gn_args+="\"${package}\"," |
| done |
| gn_args+="] |
| |
| # See: fx args --list=universe_package_labels |
| universe_package_labels+=[" |
| |
| for package in "${universe_packages[@]}"; do |
| gn_args+="\"${package}\"," |
| done |
| gn_args+="] |
| |
| # See: fx args --list=host_labels |
| host_labels+=[" |
| |
| for label in "${host_labels[@]}"; do |
| gn_args+="\"${label}\"," |
| done |
| gn_args+="]" |
| |
| if [[ -n "${variant}" ]]; then |
| gn_args+=" select_variant=[${variant}]" |
| fi |
| |
| if [[ "${cargo_toml_gen}" -eq 1 ]]; then |
| gn_args+=" base_package_labels += [ \"//build/rust:cargo_toml_gen\" ]" |
| fi |
| |
| gn_args+="${gn_after_args}" |
| |
| fx-gn ${gn_cmd} "${build_dir}" "${gn_switches[@]}" --args="${gn_args}" "$@" |
| |
| fx-change-build-dir "${config_build_dir}" |
| |
| if [[ "${use_goma}" -eq 1 ]] && [[ "${ensure_goma}" -eq 1 ]]; then |
| fx-command-run goma || return $? |
| fi |
| } |
| |
| main "$@" |
