build_image: remove --dev_install flag

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 52 matching lines @@
   "Use INSTALL_MASK to shrink the resulting image."
 DEFINE_integer jobs -1 \
   "How many packages to build in parallel at maximum."
 DEFINE_boolean statefuldev ${FLAGS_TRUE} \
   "Install development packages on stateful partition rather than the rootfs"
 DEFINE_string to "" \
   "The target image file or device"
 DEFINE_boolean factory_install ${FLAGS_FALSE} \
   "Build a smaller image to overlay the factory install shim on; this argument \
 is also required in image_to_usb."
-DEFINE_boolean dev_install ${FLAGS_FALSE} \
-  "Build a smaller image to overlay the dev recovery install shim on"
 DEFINE_integer rootfs_partition_size 1024 \
   "rootfs partition size in MiBs."
 DEFINE_integer rootfs_size 850 \
   "rootfs filesystem size in MiBs."
 # ceil(0.1 * rootfs_size) is a good minimum.
 DEFINE_integer rootfs_hash_pad 8 \
   "MiBs reserved at the end of the rootfs image."
 DEFINE_integer statefulfs_size 1024 \
   "stateful filesystem size in MiBs."
 DEFINE_boolean preserve ${FLAGS_FALSE} \
@@ skipping 52 matching lines @@
   fi
   info "No blacklisted packages found."
 }
 
 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
 
-# Verify user didn't specify incompatible flags for dev install shim
-if [ "${FLAGS_factory_install}" -eq "${FLAGS_TRUE}" ] &&
-   [ "${FLAGS_dev_install}" -eq "${FLAGS_TRUE}" ] ; then
-  die "Incompatible flags: --factory_install and --dev_install cannot be \
-both set to True. Please specify one or none."
-fi
+# TODO(vlaviano): validate flags

[jrbarnette, 2011/03/16 01:01:46]

What's this about?  If the comment is actually relevant to the code you
want to push, I think it needs a bit more detail.

[Vince Laviano, 2011/03/16 01:21:16]

The code that I deleted from here was examining a single set of mutually
incompatible flags (--factory_install and --dev_install) and ensuring that both
are not set. I added the comment to remind myself to perform a much more
comprehensive validation of flags as I rewrite build_image, since I will no
longer have this deleted code here as a reminder to do so.

 
 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}" ] ||
-   [ "${FLAGS_dev_install}" -eq "${FLAGS_TRUE}" ] ; then
-  # Disable --withdev flag when --*_install is set to True. Otherwise, the
+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
-    info "Incompatible flags: --withdev and --dev_install or --factory_install \
-cannot be both set to True. Reset --withdev to False."
+    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"
@@ skipping 43 matching lines @@
 
 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
   PRISTINE_IMAGE_NAME=chromiumos_base_image.bin
   DEVELOPER_IMAGE_NAME=chromiumos_image.bin
-elif [ "${FLAGS_dev_install}" -eq "${FLAGS_TRUE}" ]; then
-# Rename pristine images for install shims
-  PRISTINE_IMAGE_NAME=dev_install_shim.bin
+# Rename pristine image for factory install shim
 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}"
 
@@ skipping 236 matching lines @@
     info "Fixing python symlinks for developer and test images."
     local python_paths="/usr/bin/python /usr/local/bin/python \
         /usr/bin/python2 /usr/local/bin/python2"
     for path in ${python_paths}; do
       sudo rm -f "${ROOT_FS_DIR}${path}"
       sudo ln -s  ${python_path} "${ROOT_FS_DIR}${path}"
     done
   fi
 
   # Check that the image has been correctly created.  Only do it if not
-  # building a factory install image and not a dev install shim, as the
-  # INSTALL_MASK for it will make test_image fail.
-  if [ ${FLAGS_factory_install} -eq ${FLAGS_FALSE} ] &&
-     [ ${FLAGS_dev_install} -eq ${FLAGS_FALSE} ] ; then
+  # building a factory install shim, as the INSTALL_MASK for it will make
+  # test_image fail.
+  if [ ${FLAGS_factory_install} -eq ${FLAGS_FALSE} ]; then
     "${SCRIPTS_DIR}/test_image" \
       --root="${ROOT_FS_DIR}" \
       --target="${ARCH}"
   fi
   echo "Developer image built and stored at ${image_name}"
 
   trap - EXIT
   ${SCRIPTS_DIR}/mount_gpt_image.sh -u -r "${ROOT_FS_DIR}" \
     -s "${STATEFUL_FS_DIR}" -e "${ESP_FS_DIR}"
 }
@@ skipping 160 matching lines @@
     enable_rootfs_verification="--enable_rootfs_verification"
   fi
 
   ${SCRIPTS_DIR}/create_legacy_bootloader_templates.sh \
     --arch=${ARCH} \
     --to="${ROOT_FS_DIR}"/boot \
     --boot_args="${FLAGS_boot_args}" \
     --install \
     ${enable_rootfs_verification}
 
-  # Don't test the factory install shim or the dev install shim
-  if [ ${FLAGS_factory_install} -eq ${FLAGS_FALSE} ] &&
-     [ ${FLAGS_dev_install} -eq ${FLAGS_FALSE} ]; then
+  # Don't test the factory install shim
+  if [ ${FLAGS_factory_install} -eq ${FLAGS_FALSE} ]; then
     # Check that the image has been correctly created.
     "${SCRIPTS_DIR}/test_image" \
       --root="${ROOT_FS_DIR}" \
       --target="${ARCH}"
   fi
 
   # Clean up symlinks so they work on a running target rooted at "/".
   # Here development packages are rooted at /usr/local.  However, do not
   # create /usr/local or /var on host (already exist on target).
   setup_symlinks_on_root "/usr/local" "/var" "${STATEFUL_FS_DIR}"
@@ skipping 68 matching lines @@
 # 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_dev_install}" -eq "${FLAGS_TRUE}" ] || \
-   [ "${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
   BOOT_FLAG=
-  if [ "${FLAGS_dev_install}" -eq "${FLAGS_TRUE}" ] ||
-     [ "${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 "--dev_install set, pass BOOT_FLAG_DEVELOPER flag to load_kernel_test"
+    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 [[ ! -f ${DEVELOPER_IMG} ]] ; then
@@ skipping 24 matching lines @@
   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."