Standardize invocations of emerge in build_image

build_image

 #!/bin/bash
 
 # Copyright (c) 2009 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # Script to build a bootable keyfob-based chromeos system image from within
 # a chromiumos setup. This assumes that all needed packages have been built into
 # the given target's root with binary packages turned on. This script will
 # build the Chrome OS image using only pre-built binary packages.
@@ skipping 127 matching lines @@
 
 check_blacklist
 
 # TODO(petkov): Remove along with the --move_to_etc flag support once the
 # transition dust settles.
 "${SCRIPTS_DIR}"/set_shared_user_password.sh --move_to_etc
 
 # TODO(vlaviano): Validate command line flags. Check for conflicting flags and
 # reconcile them if possible. Exit with an error message otherwise.
 
-INSTALL_MASK=""
-if [ "${FLAGS_installmask}" -eq "${FLAGS_TRUE}" ] ; then
+export INSTALL_MASK=""
+if [ ${FLAGS_installmask} -eq ${FLAGS_TRUE} ] ; then
   INSTALL_MASK="${DEFAULT_INSTALL_MASK}"
 fi
 
 # Reduce the size of factory install shim.
-if [ "${FLAGS_factory_install}" -eq "${FLAGS_TRUE}" ]; then
+if [ ${FLAGS_factory_install} -eq ${FLAGS_TRUE} ]; then
   # Disable --withdev flag when --factory_install is set to True. Otherwise, the
   # dev image produced will be based on install shim, rather than a pristine
   # image
-  if [ "${FLAGS_withdev}" -eq "${FLAGS_TRUE}" ]; then
+  if [ ${FLAGS_withdev} -eq ${FLAGS_TRUE} ]; then
     info "Incompatible flags: --withdev and --factory_install cannot both be \
 set to True. Resetting --withdev to False."
     FLAGS_withdev=${FLAGS_FALSE}
   fi
 
   # TODO: Build a separated ebuild for the install shim to reduce size.
   INSTALL_MASK="${INSTALL_MASK} ${FACTORY_INSTALL_MASK}"
 
   info "Fixing the rootfs size at 300 MiB for install shim"
   FLAGS_rootfs_size=280
   FLAGS_rootfs_partition_size=300
   info "Fixing the statefulfs size at 140 MiB for install shim"
   FLAGS_statefulfs_size=140
 fi
 
-if [ "$((FLAGS_rootfs_size + FLAGS_rootfs_hash_pad))" -gt \
-     "${FLAGS_rootfs_partition_size}" ] ; then
+if [ $((FLAGS_rootfs_size + FLAGS_rootfs_hash_pad)) -gt \
+     ${FLAGS_rootfs_partition_size} ] ; then
   die "rootfs ($((FLAGS_rootfs_size + FLAGS_rootfs_hash_pad)) MiB) is \
 bigger than partition (${FLAGS_rootfs_partition_size} MiB)."
 fi
 
 EMERGE_BOARD_CMD="emerge-${FLAGS_board}"
-if [ "${FLAGS_fast}" -eq "${FLAGS_TRUE}" ]; then
+if [ ${FLAGS_fast} -eq ${FLAGS_TRUE} ]; then
   echo "Using alternate emerge"
   EMERGE_CMD="${GCLIENT_ROOT}/chromite/bin/parallel_emerge"
   EMERGE_BOARD_CMD="${EMERGE_CMD} --board=${FLAGS_board}"
 fi
 
 OVERLAY_CHROMEOS_DIR="${SRC_ROOT}/third_party/chromiumos-overlay/chromeos/"
 
 # Determine build version.
 . "${OVERLAY_CHROMEOS_DIR}/config/chromeos_version.sh"
 
 # Configure extra USE or packages for this type of build.
 EXTRA_PACKAGES=""
-EXTRA_USE=""
-if [ "${FLAGS_factory_install}" -eq "${FLAGS_TRUE}" ] ; then
+if [ ${FLAGS_factory_install} -eq ${FLAGS_TRUE} ] ; then
   # Factory install needs to have the kernel initrmafs enabled,
   # and the factory installer added.
   EXTRA_PACKAGES="${EXTRA_PACKAGES} chromeos-base/chromeos-factoryinstall"
-  EXTRA_USE="${EXTRA_USE} initramfs"
+  export USE="${USE} initramfs"
 fi
 
+emerge_to_image() {
+  sudo -E ${EMERGE_BOARD_CMD} --root-deps=rdeps --usepkgonly \
+    "$@" ${EMERGE_JOBS}
+}
+
 # Freshen kernel with correct USE flags. This is a noop if we have
 # the right kernel prebuilt. Factory install uses USE="initramfs".
 # We don't allow building from source with the image as a target,
 # and it's not possible to store prebuilts for the same package
 # with different use flags.
-USE="${EXTRA_USE} ${USE}" emerge-${FLAGS_board} \
-    -uNDvg --binpkg-respect-use=y virtual/kernel
+sudo -E ${EMERGE_BOARD_CMD} -uDNv -g virtual/kernel
 
 # Use canonical path since some tools (e.g. mount) do not like symlinks.
 # Append build attempt to output directory.
 IMAGE_SUBDIR="${CHROMEOS_VERSION_STRING}-a${FLAGS_build_attempt}"
 OUTPUT_DIR="${FLAGS_output_root}/${FLAGS_board}/${IMAGE_SUBDIR}"
 
 OUTSIDE_OUTPUT_DIR="../build/images/${FLAGS_board}/${IMAGE_SUBDIR}"
 
 # If we are creating a developer image, also create a pristine image with a
 # different name.
 DEVELOPER_IMAGE_NAME=
 PRISTINE_IMAGE_NAME=chromiumos_image.bin
-if [ "${FLAGS_withdev}" -eq "${FLAGS_TRUE}" ]; then
+if [ ${FLAGS_withdev} -eq ${FLAGS_TRUE} ]; then
   PRISTINE_IMAGE_NAME=chromiumos_base_image.bin
   DEVELOPER_IMAGE_NAME=chromiumos_image.bin
 # Rename pristine image for factory install shim
-elif [ "${FLAGS_factory_install}" -eq "${FLAGS_TRUE}" ]; then
+elif [ ${FLAGS_factory_install} -eq ${FLAGS_TRUE} ]; then
   PRISTINE_IMAGE_NAME=factory_install_shim.bin
 fi
 
 PRISTINE_IMG="${OUTPUT_DIR}/${PRISTINE_IMAGE_NAME}"
 DEVELOPER_IMG="${OUTPUT_DIR}/${DEVELOPER_IMAGE_NAME}"
 
 BOARD="${FLAGS_board}"
 BOARD_ROOT="${FLAGS_build_root}/${BOARD}"
 
 ROOT_FS_IMG="${OUTPUT_DIR}/rootfs.image"
@@ skipping 175 matching lines @@
   ${SCRIPTS_DIR}/mount_gpt_image.sh --from "${OUTPUT_DIR}" \
     --image "${image_name}" -r "${ROOT_FS_DIR}" \
     -s "${STATEFUL_FS_DIR}" -e "${ESP_FS_DIR}"
 
   # Determine the root dir for developer packages.
   local root_dev_dir="${ROOT_FS_DIR}"
   [ ${FLAGS_statefuldev} -eq ${FLAGS_TRUE} ] && \
     root_dev_dir="${ROOT_FS_DIR}/usr/local"
 
   # Install developer packages described in chromeos-dev.
-  sudo -E USE="${USE} ${EXTRA_USE}" INSTALL_MASK="${INSTALL_MASK}" \
-      ${EMERGE_BOARD_CMD} --root="${root_dev_dir}" --root-deps=rdeps \
-      --usepkgonly -uDNv chromeos-dev ${EMERGE_JOBS}
+  emerge_to_image --root="${root_dev_dir}" -uDNv chromeos-dev
 
   if [[ $FLAGS_preserve -eq ${FLAGS_TRUE} ]] ; then
     # Clean out unused packages
-    sudo -E USE="${USE} ${EXTRA_USE}" INSTALL_MASK="${INSTALL_MASK}" \
-      ${EMERGE_BOARD_CMD} --root="${ROOT_FS_DIR}" --root-deps=rdeps \
-      --usepkgonly --depclean ${EMERGE_JOBS}
+    emerge_to_image --root="${ROOT_FS_DIR}" --depclean
   fi
 
   # Install the bare necessary files so that the "emerge" command works
   if [ ${FLAGS_statefuldev} -eq ${FLAGS_TRUE} ]; then
     sudo cp -a ${root_dev_dir}/share/portage ${ROOT_FS_DIR}/usr/share
     sudo sed -i s,/usr/bin/wget,wget, \
       ${ROOT_FS_DIR}/usr/share/portage/config/make.globals
   fi
   sudo mkdir -p ${ROOT_FS_DIR}/etc/make.profile
 
@@ skipping 59 matching lines @@
   echo "Updating base packages on ${image_name}"
 
   # Create stateful partition of the same size as the rootfs.
   trap "mount_gpt_cleanup" EXIT
 
   ${SCRIPTS_DIR}/mount_gpt_image.sh --from "${OUTPUT_DIR}" \
     --image "${image_name}" -r "${ROOT_FS_DIR}" \
     -s "${STATEFUL_FS_DIR}" -e "${ESP_FS_DIR}"
 
   # Emerge updated packages, exactly like when creating base image
-  sudo USE="${EXTRA_USE}" INSTALL_MASK="${INSTALL_MASK}" ${EMERGE_BOARD_CMD} \
-    --root="${ROOT_FS_DIR}" --root-deps=rdeps \
-    --usepkgonly -uDNv chromeos ${EXTRA_PACKAGES} ${EMERGE_JOBS}
+  emerge_to_image --root="${ROOT_FS_DIR}" -uDNv chromeos ${EXTRA_PACKAGES}
 
   # Clean out unused packages
-  sudo INSTALL_MASK="${INSTALL_MASK}" ${EMERGE_BOARD_CMD} \
-    --root="${ROOT_FS_DIR}" --root-deps=rdeps \
-    --usepkgonly --depclean ${EMERGE_JOBS}
+  emerge_to_image --root="${ROOT_FS_DIR}" --depclean
 
   trap - EXIT
   ${SCRIPTS_DIR}/mount_gpt_image.sh -u -r "${ROOT_FS_DIR}" \
     -s "${STATEFUL_FS_DIR}" -e "${ESP_FS_DIR}"
 }
 
 zero_free_space() {
   local fs_mount_point=$1
   info "Zeroing freespace in ${fs_mount_point}"
   # dd is a silly thing and will produce a "No space left on device" message
@@ skipping 104 matching lines @@
   sudo mkdir -p "${ROOT_FS_DIR}/usr/local"
   sudo mount --bind "${DEV_IMAGE_ROOT}" "${ROOT_FS_DIR}/usr/local"
   sudo mkdir -p "${ROOT_FS_DIR}/var"
   sudo mount --bind "${STATEFUL_FS_DIR}/var" "${ROOT_FS_DIR}/var"
   sudo mkdir -p "${ROOT_FS_DIR}/dev"
 
   # We "emerge --root=${ROOT_FS_DIR} --root-deps=rdeps --usepkgonly" all of the
   # runtime packages for chrome os. This builds up a chrome os image from
   # binary packages with runtime dependencies only.  We use INSTALL_MASK to
   # trim the image size as much as possible.
-  sudo USE="${EXTRA_USE}" INSTALL_MASK="${INSTALL_MASK}" ${EMERGE_BOARD_CMD} \
-    --root="${ROOT_FS_DIR}" --root-deps=rdeps \
-    --usepkgonly chromeos ${EXTRA_PACKAGES} ${EMERGE_JOBS}
+  emerge_to_image --root="${ROOT_FS_DIR}" chromeos ${EXTRA_PACKAGES}
 
   # Set /etc/lsb-release on the image.
   "${OVERLAY_CHROMEOS_DIR}/scripts/cros_set_lsb_release" \
     --root="${ROOT_FS_DIR}" \
     --board="${BOARD}"
 
   # Populates the root filesystem with legacy bootloader templates
   # appropriate for the platform.  The autoupdater and installer will
   # use those templates to update the legacy boot partition (12/ESP)
   # on update.
@@ skipping 77 matching lines @@
 
     # Copy forward the developer image, if we already copied forward the base.
     if [[ ${FLAGS_withdev} -eq ${FLAGS_TRUE} ]] && \
        [[ -f ${PREVIOUS_DIR}/${DEVELOPER_IMAGE_NAME} ]] ; then
       cp ${PREVIOUS_DIR}/${DEVELOPER_IMAGE_NAME} ${OUTPUT_DIR}
     fi
   fi
 fi
 
 # Perform an eclean to remove packages which are not installed
-if [[ "${FLAGS_eclean}" -eq "${FLAGS_TRUE}" ]]; then
+if [[ ${FLAGS_eclean} -eq ${FLAGS_TRUE} ]]; then
   eclean-${FLAGS_board} -d packages
 fi
 
 # Create the boot.desc file which stores the build-time configuration
 # information needed for making the image bootable after creation with
 # cros_make_image_bootable.
 create_boot_desc
 
 if [[ -f ${PRISTINE_IMG} ]] ; then
   update_base_packages ${PRISTINE_IMAGE_NAME}
 else
   create_base_image ${PRISTINE_IMAGE_NAME}
 fi
 
 USE_DEV_KEYS=
-if [ "${FLAGS_factory_install}" -eq "${FLAGS_TRUE}" ]; then
+if [ ${FLAGS_factory_install} -eq ${FLAGS_TRUE} ]; then
   USE_DEV_KEYS="--use_dev_keys"
 fi
 
 # Place flags before positional args
 ${SCRIPTS_DIR}/bin/cros_make_image_bootable "${OUTPUT_DIR}" \
                                             "${PRISTINE_IMAGE_NAME}" \
                                             ${USE_DEV_KEYS} \
                                             ${crosbug12352_flag}
 
 # FIXME Test x86 image, and test arm image if enabled;
 # should unconditionally test an image after crosbug12352 is fixed
 if [[ "${ARCH}" = "x86" ]] ||
    [[ "${ARCH}" = "arm" &&
-      "${FLAGS_crosbug12352_arm_kernel_signing}" -eq "${FLAGS_TRUE}" ]]; then
+      ${FLAGS_crosbug12352_arm_kernel_signing} -eq ${FLAGS_TRUE} ]]; then
   BOOT_FLAG=
-  if [ "${FLAGS_factory_install}" -eq "${FLAGS_TRUE}" ]; then
+  if [ ${FLAGS_factory_install} -eq ${FLAGS_TRUE} ]; then
     BOOT_FLAG="-b 1"  # BOOT_FLAG_DEVELOPER value defined in load_kernel_fw.h
     info "--factory_install set, pass BOOT_FLAG_DEVELOPER flag to \
 load_kernel_test"
   fi
 
   # Verify the final image.
   load_kernel_test "${OUTPUT_DIR}/${PRISTINE_IMAGE_NAME}" \
     "${DEVKEYSDIR}/recovery_key.vbpubk" ${BOOT_FLAG}
 fi
 
 # Create a developer image based on the chromium os base image.
-if [ "${FLAGS_withdev}" -eq "${FLAGS_TRUE}" ] ; then
+if [ ${FLAGS_withdev} -eq ${FLAGS_TRUE} ] ; then
   if [[ ! -f ${DEVELOPER_IMG} ]] ; then
     echo "Creating developer image from base image ${PRISTINE_IMAGE_NAME}"
     cp ${PRISTINE_IMG} ${DEVELOPER_IMG}
   fi
 
   update_dev_packages ${DEVELOPER_IMAGE_NAME}
   ${SCRIPTS_DIR}/bin/cros_make_image_bootable "${OUTPUT_DIR}" \
                                               "${DEVELOPER_IMAGE_NAME}" \
                                               ${crosbug12352_flag}
 fi
 
 # Clean up temporary files.
 rm -f "${ROOT_FS_IMG}" "${STATEFUL_FS_IMG}" "${OUTPUT_DIR}/vmlinuz.image" \
   "${ESP_FS_IMG}" "${OUTPUT_DIR}/vmlinuz_hd.vblock"
 rmdir "${ROOT_FS_DIR}" "${STATEFUL_FS_DIR}" "${ESP_FS_DIR}"
 
 # Generating AU generator zip file to run outside chroot
 generate_au_zip || echo "Failed generating AU zip file - ignoring Error..."
 # Create a 'latest' link
 rm -f ${FLAGS_output_root}/${FLAGS_board}/latest
 ln -s $(basename ${OUTPUT_DIR}) ${FLAGS_output_root}/${FLAGS_board}/latest
 
 echo "Done.  Image created in ${OUTPUT_DIR}"
 echo "Chromium OS image created as ${PRISTINE_IMAGE_NAME}"
-if [ "${FLAGS_withdev}" -eq "${FLAGS_TRUE}" ]; then
+if [ ${FLAGS_withdev} -eq ${FLAGS_TRUE} ]; then
   echo "Developer image created as ${DEVELOPER_IMAGE_NAME}"
 fi
 
 print_time_elapsed
 
 echo "To copy to USB keyfob, do something like:"
 echo "  ./image_to_usb.sh --from=${OUTSIDE_OUTPUT_DIR} --to=/dev/sdX"
 echo "To convert to VMWare image, INSIDE the chroot, do something like:"
 echo "  ./image_to_vm.sh --from=${OUTSIDE_OUTPUT_DIR} --board=${BOARD}"
 echo "from the scripts directory where you entered the chroot."