crosutils: refine memento image / factory package creation

make_factory_package.sh

 #!/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 generate a factory install partition set and miniomaha.conf
 # file from a release image and a factory image. This creates a server
 # configuration that can be installed using a factory install shim.
 #
 # miniomaha lives in src/platform/dev/ and miniomaha partition sets live
 # in src/platform/dev/static.
 
 # Load common constants.  This should be the first executable line.
 # The path to common.sh should be relative to your script's location.
 . "$(dirname "$0")/common.sh"
 
 # Load functions and constants for chromeos-install
 . "$(dirname "$0")/chromeos-common.sh"
 
+# Load functions designed for image processing
+. "$(dirname "$0")/image_common.sh"
+
 get_default_board
 
 # Flags
 DEFINE_string board "${DEFAULT_BOARD}" "Board for which the image was built"
 DEFINE_string factory "" \
   "Directory and file containing factory image: /path/chromiumos_test_image.bin"
 DEFINE_string firmware_updater "" \
   "If set, include the firmware shellball into the server configuration"
 DEFINE_string release "" \
   "Directory and file containing release image: /path/chromiumos_image.bin"
@@ skipping 57 matching lines @@
 }
 
 prepare_dir() {
   sudo rm -rf rootfs-test.gz
   sudo rm -rf rootfs-release.gz
   rm -rf efi.gz
   rm -rf oem.gz
   rm -rf state.gz
 }
 
+compress_and_hash_memento_image() {
+  local input_file="$1"
+
+  if has_part_tools; then
+    sudo "${SCRIPTS_DIR}/mk_memento_images.sh" "$input_file" 2 3 |
+      grep hash |
+      awk '{print $4}'
+  else
+    sudo "${SCRIPTS_DIR}/mk_memento_images.sh" part_2 part_3 |
+      grep hash |
+      awk '{print $4}'
+  fi
+}
+
+compress_and_hash_file() {
+  local input_file="$1"
+  local output_file="$2"
+
+  if [ -z "$input_file" ]; then
+    # Runs as a pipe processor
+    gzip_compress -c -9 |
+    tee "$output_file" |
+    openssl sha1 -binary |
+    openssl base64
+  else
+    gzip_compress -c -9 "$input_file" |
+    tee "$output_file" |
+    openssl sha1 -binary |
+    openssl base64
+  fi
+}
+
+compress_and_hash_partition() {
+  local input_file="$1"
+  local part_num="$2"
+  local output_file="$3"
+
+  if has_part_tools; then
+    dump_partition "$input_file" "$part_num" |
+    compress_and_hash_file "" "$output_file"
+  else
+    compress_and_hash_file "part_$part_num" "$output_file"
+  fi
+}
 
 # Clean up stale config and data files.
 prepare_omaha
 
 # Get the release image.
 pushd ${RELEASE_DIR} > /dev/null
 echo "Generating omaha release image from ${FLAGS_release}"
 echo "Generating omaha factory image from ${FLAGS_factory}"
 echo "Output omaha image to ${OMAHA_DATA_DIR}"
 echo "Output omaha config to ${OMAHA_DIR}/miniomaha.conf"
 
 prepare_dir
 
-sudo ./unpack_partitions.sh ${RELEASE_IMAGE} &> /dev/null
-release_hash=`sudo ${SCRIPTS_DIR}/mk_memento_images.sh part_2 part_3 \
-    | grep hash | awk '{print $4}'`
+if ! has_part_tools; then
+  #TODO(hungte) we can still avoid running unpack_partitions.sh
+  # by $(cat unpack_partitions.sh | grep Label | sed "s/#//" | grep ${name}" |
+  #      awk '{ print $1}') to fetch offset/size.
+  echo "Unpacking image ${RELEASE_IMAGE} ..." >&2
+  sudo ./unpack_partitions.sh "${RELEASE_IMAGE}" 2>/dev/null
+fi
+
+release_hash="$(compress_and_hash_memento_image "${RELEASE_IMAGE}")"
 sudo chmod a+rw update.gz
 mv update.gz rootfs-release.gz
 mv rootfs-release.gz ${OMAHA_DATA_DIR}
 echo "release: ${release_hash}"
 
-cat part_8 | gzip -9 > oem.gz
-oem_hash=`cat oem.gz | openssl sha1 -binary | openssl base64`
+oem_hash="$(compress_and_hash_partition "${RELEASE_IMAGE}" 8 "oem.gz")"
 mv oem.gz ${OMAHA_DATA_DIR}
 echo "oem: ${oem_hash}"
 
-cat part_12 | gzip -9 > efi.gz
-efi_hash=`cat efi.gz | openssl sha1 -binary | openssl base64`
+efi_hash="$(compress_and_hash_partition "${RELEASE_IMAGE}" 12 "efi.gz")"
 mv efi.gz ${OMAHA_DATA_DIR}
 echo "efi: ${efi_hash}"
 
 popd > /dev/null
 
 # Go to retrieve the factory test image.
 pushd ${FACTORY_DIR} > /dev/null
 prepare_dir
 
+if ! has_part_tools; then
+  echo "Unpacking image ${FACTORY_IMAGE} ..." >&2
+  sudo ./unpack_partitions.sh "${FACTORY_IMAGE}" 2>/dev/null
+fi
 
-sudo ./unpack_partitions.sh ${FACTORY_IMAGE} &> /dev/null
-test_hash=`sudo ${SCRIPTS_DIR}//mk_memento_images.sh part_2 part_3 \
-    | grep hash | awk '{print $4}'`
+test_hash="$(compress_and_hash_memento_image "${FACTORY_IMAGE}")"
 sudo chmod a+rw update.gz
 mv update.gz rootfs-test.gz
 mv rootfs-test.gz ${OMAHA_DATA_DIR}
 echo "test: ${test_hash}"
 
-cat part_1 | gzip -9 > state.gz
-state_hash=`cat state.gz | openssl sha1 -binary | openssl base64`
+state_hash="$(compress_and_hash_partition "${FACTORY_IMAGE}" 1 "state.gz")"
 mv state.gz ${OMAHA_DATA_DIR}
 echo "state: ${state_hash}"
 
 popd > /dev/null
 
 if [ ! -z ${FLAGS_firmware_updater} ] ; then
   SHELLBALL="${FLAGS_firmware_updater}"
   if [ ! -f  "$SHELLBALL" ]; then
     echo "Failed to find firmware updater: $SHELLBALL."
     exit 1
   fi
 
-  cat $SHELLBALL | gzip -9 > firmware.gz
-  firmware_hash=`cat firmware.gz | openssl sha1 -binary | openssl base64`
+  firmware_hash="$(compress_and_hash_file "$SHELLBALL" "firmware.gz")"
   mv firmware.gz ${OMAHA_DATA_DIR}
   echo "firmware: ${firmware_hash}"
 fi
 
 # If the file does exist and we are using the subfolder flag we are going to
 # append another config.
 if [ -n "${FLAGS_subfolder}" ] && \
    [ -f "${OMAHA_DIR}"/miniomaha.conf"" ] ; then
   # Remove the ']' from the last line of the file so we can add another config.
   sed -i '$d' ${OMAHA_DIR}/miniomaha.conf
@@ skipping 28 matching lines @@
  },
 ]
 " >> ${OMAHA_DIR}/miniomaha.conf
 
 echo "The miniomaha server lives in src/platform/dev"
 echo "to validate the configutarion, run:"
 echo "  python2.6 devserver.py --factory_config miniomaha.conf \
 --validate_factory_config"
 echo "To run the server:"
 echo "  python2.6 devserver.py --factory_config miniomaha.conf"