Add -b option to run_remote_tests to build tests before running

src/scripts/run_remote_tests.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 run client or server tests on a live remote image.
 
 # 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"
 . "$(dirname $0)/autotest_lib.sh"
 . "$(dirname $0)/remote_access.sh"
 
+DEFINE_boolean build ${FLAGS_FALSE} "Build tests as well as running them" b
 DEFINE_string chroot "${DEFAULT_CHROOT_DIR}" "alternate chroot location" c
 DEFINE_boolean cleanup ${FLAGS_FALSE} "Clean up temp directory"
 DEFINE_integer iterations 1 "Iterations to run every top level test" i
 DEFINE_string prepackaged_autotest "" "Use this prepackaged autotest dir"
 DEFINE_string results_dir_root "" "alternate root results directory"
 DEFINE_boolean verbose ${FLAGS_FALSE} "Show verbose autoserv output" v
 
+RAN_ANY_TESTS=${FLAGS_FALSE}
+
 # Check if our stdout is a tty
 function is_a_tty() {
   local stdout=$(readlink /proc/$$/fd/1)
   [[ "${stdout#/dev/tty}" != "${stdout}" ]] && return 0
   [[ "${stdout#/dev/pts}" != "${stdout}" ]] && return 0
   return 1
 }
 
 # Writes out text in specified color if stdout is a tty
 # Arguments:
 #   $1 - color
 #   $2 - text to color
 #   $3 - text following colored text (default colored)
 # Returns:
 #   None
 function echo_color() {
   local color=0
   [[ "$1" == "red" ]] && color=31
   [[ "$1" == "green" ]] && color=32
   [[ "$1" == "yellow" ]] && color=33
   if is_a_tty; then
     echo -e "\033[1;${color}m$2\033[0m$3"
   else
     echo "$2$3"
   fi
 }
 
 function cleanup() {
-  if [[ $FLAGS_cleanup -eq ${FLAGS_TRUE} ]]; then
+  if [[ $FLAGS_cleanup -eq ${FLAGS_TRUE} ]] || \
+     [[ ${RAN_ANY_TESTS} -eq ${FLAGS_FALSE} ]]; then
     rm -rf "${TMP}"
   else
     echo ">>> Details stored under ${TMP}"
   fi
   cleanup_remote_access
 }
 
 # Returns an error if the test_result_file has text which indicates
 # the test was not run successfully.
 # Arguments:
@@ skipping 50 matching lines @@
   fi
   remote_sh grep CHROMEOS_RELEASE_BOARD /etc/lsb-release
   FLAGS_board=$(echo "${REMOTE_OUT}" | cut -d= -f2)
   if [[ -z "${FLAGS_board}" ]]; then
     check_board
   fi
   echo "Target reports board is ${FLAGS_board}"
 }
 
 
+# Determine if a control is for a client or server test.  Echos
+# either "server" or "client".
+# Arguments:
+#   $1 - control file path
+function read_test_type() {
+  local control_file=$1
+  # Assume a line starts with TEST_TYPE =
+  local type=$(egrep '^[[:space:]]*TEST_TYPE[[:space:]]*=' "${control_file}" \

[petkov, 2010/03/29 21:37:38]

You could use egrep -m1 instead of piping through head -1

+    | head -1)
+  if [[ -z "${type}" ]]; then
+    echo_color "red" ">>> Unable to find TEST_TYPE line in ${control_file}"
+    exit 1
+  fi
+  type=$(python -c "${type}; print TEST_TYPE.lower()")
+  if [[ "${type}" != "client" ]] && [[ "${type}" != "server" ]]; then
+    echo_color "red" ">>> Unknown type of test (${type}) in ${control_file}"

[petkov, 2010/03/29 21:37:38]

Consider using die, warn, etc. from common.sh instead.

+    exit 1
+  fi
+  echo ${type}
+}
+
 function main() {
   cd $(dirname "$0")
 
   FLAGS "$@" || exit 1
 
   if [[ -z "${FLAGS_ARGV}" ]]; then
     echo "Please specify tests to run.  For example:"
     echo "  $0 --remote=MyMachine BootPerfServer"
     exit 1
   fi
@@ skipping 28 matching lines @@
   local control_files_to_run=""
 
   # Now search for tests which unambiguously include the given identifier
   local search_path=$(echo ${autotest_dir}/{client,server}/{tests,site_tests})
   for test_request in $FLAGS_ARGV; do
     test_request=$(remove_quotes "${test_request}")
     ! finds=$(find ${search_path} -maxdepth 2 -type f \( -name control.\* -or \
       -name control \) | egrep -v "~$" | egrep "${test_request}")
     if [[ -z "${finds}" ]]; then
       echo_color "red" ">>> Cannot find match for \"${test_request}\""
-      FLAGS_cleanup=${FLAGS_TRUE}
       exit 1
     fi
     local matches=$(echo "${finds}" | wc -l)
     if [[ ${matches} -gt 1 ]]; then
       echo ""
       echo_color "red" \
         ">>> \"${test_request}\" is ambiguous.  These control file paths match:"
       for FIND in ${finds}; do
         echo_color "red" " * " "${FIND}"
       done
       echo ""
       echo ">>> Disambiguate by copy-and-pasting the whole path above" \
            "instead of passing \"${test_request}\"."
-      FLAGS_cleanup=${FLAGS_TRUE}
       exit 1
     fi
     for i in $(seq 1 $FLAGS_iterations); do
       control_files_to_run="${control_files_to_run} '${finds}'"
     done
   done
 
   echo ""
+
+  if [[ -z "${control_files_to_run}" ]]; then
+    echo_color "red" ">>> Found no control files"
+    exit 1
+  fi
+
   echo_color "yellow" ">>> Running the following control files:"
   for CONTROL_FILE in ${control_files_to_run}; do
     echo_color "yellow" " * " "${CONTROL_FILE}"
   done
 
   if [[ -z "${FLAGS_results_dir_root}" ]]; then
     FLAGS_results_dir_root="${TMP}"
   fi
 
   mkdir -p "${FLAGS_results_dir_root}"
 
+  if [[ ${FLAGS_build} -eq ${FLAGS_TRUE} ]]; then
+    # Create a list of files to build based on all the client tests
+    # the user has specified.  If they have specified at least one
+    # that is a server test, offer to build all client tests since
+    # it's quite hard to know what client tests a server test might
+    # use.
+    local build_param=""
+    for control_file in ${control_files_to_run}; do
+      control_file=$(remove_quotes "${control_file}")
+      local type=$(read_test_type "${control_file}")
+      if [[ "${type}" == "server" ]]; then
+        build_param=""
+        break
+      fi
+      if [[ -n "${build_param}" ]]; then
+        build_param="${build_param},"
+      fi
+      local simple_path=$(basename $(dirname $control_file))
+      build_param="${build_param}${simple_path}"

[ericli, 2010/03/29 21:33:22]

I think it needs to be seperated by comma, if there are multiple tests to build.

+    done
+    local enter_chroot=""
+    if [[ ${INSIDE_CHROOT} -eq 0 ]]; then
+      enter_chroot="./enter_chroot.sh --"
+    fi
+    if [[ -n "${build_param}" ]]; then
+      build_param="--build=${build_param}"
+    fi
+    echo ""
+    echo_color "yellow" ">>> Building autotest: " \
+      "./build_autotest.sh --board=${FLAGS_board} ${build_param}"
+    ${enter_chroot} ./build_autotest.sh --board=${FLAGS_board} ${build_param}
+  fi
+
   for control_file in ${control_files_to_run}; do
     # Assume a line starts with TEST_TYPE =
     control_file=$(remove_quotes "${control_file}")
-    local type=$(egrep '^[[:space:]]*TEST_TYPE[[:space:]]*=' "${control_file}" \
-      | head -1)
-    if [[ -z "${type}" ]]; then
-      echo_color "red" ">>> Unable to find TEST_TYPE line in ${control_file}"
-      exit 1
-    fi
-    type=$(python -c "${type}; print TEST_TYPE.lower()")
+    local type=$(read_test_type "${control_file}")
     local option
-    if [ "${type}" == "client" ]; then
+    if [[ "${type}" == "client" ]]; then
       option="-c"
-    elif [ "${type}" == "server" ]; then
+    elif [[ "${type}" == "server" ]]; then
       option="-s"
     else
       echo_color "red" ">>> Unknown type of test (${type}) in ${control_file}"
       exit 1
     fi
     echo ""
     echo_color "yellow" ">>> Running ${type} test " ${control_file}
     local short_name=$(basename $(dirname "${control_file}"))
     local results_dir_name="${short_name}"
     local results_dir="${FLAGS_results_dir_root}/${results_dir_name}"
     rm -rf "${results_dir}"
     local verbose=""
     if [[ ${FLAGS_verbose} -eq $FLAGS_TRUE ]]; then
       verbose="--verbose"
     fi
 
+    RAN_ANY_TESTS=${FLAGS_TRUE}
     ${autoserv} -m "${FLAGS_remote}" "${option}" "${control_file}" \
       -r "${results_dir}" ${verbose}
     local test_status="${results_dir}/status.log"
     local test_result_dir="${results_dir}/${short_name}"
     local keyval_file="${test_result_dir}/results/keyval"
     echo ""
     if is_successful_test "${test_status}"; then
       echo_color "green" ">>> SUCCESS: ${control_file}"
       if [[ -f "${keyval_file}" ]]; then
         echo ">>> Keyval was:"
         cat "${keyval_file}"
       fi
     else
       echo_color "red" ">>> FAILED: ${control_file}"
       cat "${test_status}"
     fi
     local end_time=$(date '+%s')
   done
 }
 
 main $@