arm64_download script waits for VM to boot before finishing.

platform_tools/barelinux/bin/arm64_download

 #!/bin/sh
 
 # Copyright 2014 Google Inc.
 #
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 
+set -e

[epoger, 2014/04/15 19:33:06]

Note that "set -e" can have its pitfalls.  See
http://mywiki.wooledge.org/BashFAQ/105

Hopefully it will work as desired in this case.

You may wish to pull that change into a separate CL, in case you need to revert
it separately... but I'll let you decide if that's worth the hassle.

+
 usage() {
     cat >&2 <<EOF
 arm64_download - this script downloads the Linaro's ARMv8 Aarch64
 toolchain and minimal embedded Linux system as well as ARM's
 foundation model.  The required files are mirrored on Google Cloud.
 
 If the files are already located in the working directory, the
 download can be skipped if the checksums match.
 
 The script then starts a emulated Arm64 Linux system in the
 background.  After the boot is complete, you can SSH into the system
 at port 8022 via user@localhost.  The SSH key will be downloaded into
 the working directery as well.
 
-Requires gsutil, xz, tar, and gunzip.
+Requires gsutil, xz, tar, md5sum, and gunzip.
 
 Usage:
   $0 WORKING_DIRECTORY
   ssh-add WORKING_DIRECTORY/key
   ...wait...
   ssh -p 8022 user@localhost
 EOF
     return 1
 }
 
-try() {
-    # print an error on nonzero return code
-    "$@"
-    local ret=$?
-    if [ $ret != 0 ] ; then
-        echo "'$@' failed and returned ${ret}." >&2
-        return $ret
-    fi
-}
-
 download_necessary_software_to_dir() (
+    echo 'Downloading necessary software.'
     cd "$1"
     local location="chromium-skia-gm/arm64env"
-    try gsutil cp "gs://${location}/md5sum.txt" . || return
-    if md5sum -c --quiet "md5sum.txt"; then
-        return 0
+    gsutil cp "gs://${location}/md5sum.txt" . 2> /dev/null
+    if ! md5sum -c --quiet "md5sum.txt"; then
+        gsutil cp "gs://${location}/*" .
     fi
-    try gsutil cp "gs://${location}/*" . || return
+    echo 'Done.'
 )
 
 install_compiler() {
     local working_dir="$1"
     local toolchain="gcc-linaro-aarch64-linux-gnu-4.8-2013.12_linux"
     (
-        try cd "$working_dir" || return
-        try test -f "${toolchain}.tar.xz" || return
-        try xz --decompress --stdout < "${toolchain}.tar.xz" | \
-            try tar xf - || return
+        cd "$working_dir"
+        test -f "${toolchain}.tar.xz"
+        xz --decompress --stdout < "${toolchain}.tar.xz" | \
+            tar xf -
     )
     local dir="${working_dir}/${toolchain}"
-    try test -d "$dir" || return
-    try test -x "${dir}/bin/aarch64-linux-gnu-gcc" || return
-    try test -x "${dir}/bin/aarch64-linux-gnu-g++" || return
+    test -d "$dir"
+    test -x "${dir}/bin/aarch64-linux-gnu-gcc"
+    test -x "${dir}/bin/aarch64-linux-gnu-g++"
 }
 
 install_runtime() {
     local working_dir="$1"
 
     local firmware='img-foundation.axf'
     local rootfs='vexpress64-openembedded_lamp-armv8-gcc-4.8_20131215-557'
     local compressed_rootfs="${rootfs}.img.CLEAN_AND_CONFIGURED.xz"
     local compressed_foundation_model='FM000-KT-00035-r0p8-52rel06.tgz'
     local keyfile='CLEAN_AND_CONFIGURED_key'
 
-    try cp "${working_dir}/$firmware" "${working_dir}/firmware" || return
+    echo 'Installing runtime files.'
+    cp "${working_dir}/$firmware" "${working_dir}/firmware"
 
-    try xz --decompress --stdout \
+    xz --decompress --stdout \
         < "${working_dir}/${compressed_rootfs}" \
-        > "${working_dir}/rootfs" || return
-    try test -f "${working_dir}/rootfs" || return
+        > "${working_dir}/rootfs"
+    test -f "${working_dir}/rootfs"
 
     (
-        try cd "$working_dir" || return
-        try test -f "$compressed_foundation_model" || return
-        try gunzip -c "$compressed_foundation_model" | try tar xf - || return
-        try test -d "Foundation_v8pkg" || return  #  Assert.
+        cd "$working_dir"
+        test -f "$compressed_foundation_model"
+        gunzip -c "$compressed_foundation_model" | tar xf -
+        test -d "Foundation_v8pkg"  #  Assert.
     )
 
-    try cp "${working_dir}/${keyfile}" "${working_dir}/key" || return
+    cp "${working_dir}/${keyfile}" "${working_dir}/key"
     chmod 'go=' "${working_dir}/key"
+    echo 'Done.'
 }
 
 start_arm64_image() {
     local working_dir="$1"
     local foundation_dir="${working_dir}/Foundation_v8pkg"
     local foundation="${foundation_dir}/models/Linux64_GCC-4.1/Foundation_v8"
     local firmware="${working_dir}/firmware"
     local rootfs="${working_dir}/rootfs"
 
-    try test -d "$foundation_dir" || return
-    try test -x "$foundation" || return
-    try test -f "$firmware" || return
-    try test -f "$rootfs" || return
+    test -d "$foundation_dir"
+    test -x "$foundation"
+    test -f "$firmware"
+    test -f "$rootfs"
 
     for PID in $(ps -o 'pid=' -C 'Foundation_v8') ; do
         kill $PID
     done
 
     DISPLAY='' nohup \
     "$foundation" \
         --image="${firmware}" \
         --cores=4 \
         --block-device="${rootfs}" \
         --network="nat" \
         --network-nat-subnet="192.168.31.0/24" \
         --network-nat-ports="8022=22" \
         > /dev/null 2>&1 &
+    echo 'Waiting for foundation model to boot...'
+    while ! ssh -i "${working_dir}/key" \
+        -o NoHostAuthenticationForLocalhost=yes \
+        -p 8022 user@localhost true 2> /dev/null; do
+        sleep 5 ;
+    done
     echo 'Listening to SSH on port 8022.'
 }
 
 arm64_download() {
     local working_directory="$1"
-    try mkdir -p "$working_directory" || return
+    mkdir -p "$working_directory"
 
-    try download_necessary_software_to_dir "$working_directory" || return
+    download_necessary_software_to_dir "$working_directory"
 
-    try install_compiler "$working_directory" || return
+    install_compiler "$working_directory"
 
-    try install_runtime "$working_directory" || return
+    install_runtime "$working_directory"
 
-    try start_arm64_image "$working_directory" || return
-
-    try start_arm64_image \
-        "$working_directory" \
-        || return
+    start_arm64_image "$working_directory"
 }
 
 for command in gsutil xz tar md5sum gunzip; do
-    try command -v "$command" > /dev/null || usage || exit
+    command -v "$command" > /dev/null || usage
 done
 
 if [ -z "$1" ] ; then
-    usage || exit
+    usage
 fi
-try arm64_download "$1"
+
+arm64_download "$1"