Merge pull request #73085 from rlenferink/patch-2

hack/gen-swagger-doc/gen-swagger-docs.sh

@@ -35,7 +35,7 @@ top_level_models=$(grep '&[A-Za-z]*{},' /register.go | sed 's/.*&//;s/{},//')
 # check if the top level models exist in the definitions.adoc. If they exist,
 # their name will be <version>.<model_name>
 VERSION="${1#*_}"
-for m in $top_level_models
+for m in ${top_level_models}
 do
   if grep -xq "=== ${VERSION}.$m" ./definitions.adoc
   then

hack/ginkgo-e2e.sh

@@ -87,7 +87,7 @@ if [[ "${KUBERNETES_PROVIDER}" == "gce" ]]; then
   set_num_migs
   NODE_INSTANCE_GROUP=""
   for ((i=1; i<=${NUM_MIGS}; i++)); do
-    if [[ $i == ${NUM_MIGS} ]]; then
+    if [[ ${i} == ${NUM_MIGS} ]]; then
       # We are assigning the same mig names as create-nodes function from cluster/gce/util.sh.
       NODE_INSTANCE_GROUP="${NODE_INSTANCE_GROUP}${NODE_INSTANCE_PREFIX}-group"
     else

hack/jenkins/benchmark-dockerized.sh

@@ -21,7 +21,7 @@ set -o xtrace
 
 retry() {
   for i in {1..5}; do
-    "$@" && return 0 || sleep $i
+    "$@" && return 0 || sleep "${i}"
   done
   "$@"
 }

hack/jenkins/test-dockerized.sh

@@ -21,7 +21,7 @@ set -o xtrace
 
 retry() {
   for i in {1..5}; do
-    "$@" && return 0 || sleep $i
+    "$@" && return 0 || sleep "${i}"
   done
   "$@"
 }

hack/lib/etcd.sh

@@ -47,12 +47,12 @@ kube::etcd::validate() {
 
   # validate installed version is at least equal to minimum
   version=$(etcd --version | tail -n +1 | head -n 1 | cut -d " " -f 3)
-  if [[ $(kube::etcd::version $ETCD_VERSION) -gt $(kube::etcd::version $version) ]]; then
-   export PATH=$KUBE_ROOT/third_party/etcd:$PATH
+  if [[ $(kube::etcd::version ${ETCD_VERSION}) -gt $(kube::etcd::version ${version}) ]]; then
+   export PATH=${KUBE_ROOT}/third_party/etcd:$PATH
    hash etcd
    echo $PATH
    version=$(etcd --version | head -n 1 | cut -d " " -f 3)
-   if [[ $(kube::etcd::version $ETCD_VERSION) -gt $(kube::etcd::version $version) ]]; then
+   if [[ $(kube::etcd::version ${ETCD_VERSION}) -gt $(kube::etcd::version ${version}) ]]; then
     kube::log::usage "etcd version ${ETCD_VERSION} or greater required."
     kube::log::info "You can use 'hack/install-etcd.sh' to install a copy in third_party/."
     exit 1

hack/lib/golang.sh

@@ -594,11 +594,11 @@ kube::golang::build_binaries_for_platform() {
 
   for binary in "${binaries[@]}"; do
     if [[ "${binary}" =~ ".test"$ ]]; then
-      tests+=($binary)
+      tests+=(${binary})
     elif kube::golang::is_statically_linked_library "${binary}"; then
-      statics+=($binary)
+      statics+=(${binary})
     else
-      nonstatics+=($binary)
+      nonstatics+=(${binary})
     fi
   done
 

hack/lib/logging.sh

@@ -57,10 +57,10 @@ kube::log::install_errexit() {
 kube::log::stack() {
   local stack_skip=${1:-0}
   stack_skip=$((stack_skip + 1))
-  if [[ ${#FUNCNAME[@]} -gt $stack_skip ]]; then
+  if [[ ${#FUNCNAME[@]} -gt ${stack_skip} ]]; then
     echo "Call stack:" >&2
     local i
-    for ((i=1 ; i <= ${#FUNCNAME[@]} - $stack_skip ; i++))
+    for ((i=1 ; i <= ${#FUNCNAME[@]} - ${stack_skip} ; i++))
     do
       local frame_no=$((i - 1 + stack_skip))
       local source_file=${BASH_SOURCE[$frame_no]}
@@ -90,7 +90,7 @@ kube::log::error_exit() {
       echo "  ${1}" >&2
     }
 
-    kube::log::stack $stack_skip
+    kube::log::stack ${stack_skip}
 
     echo "Exiting with status ${code}" >&2
   fi
@@ -130,7 +130,7 @@ kube::log::usage_from_stdin() {
 # Print out some info that isn't a top level status line
 kube::log::info() {
   local V="${V:-0}"
-  if [[ $KUBE_VERBOSE < $V ]]; then
+  if [[ ${KUBE_VERBOSE} < ${V} ]]; then
     return
   fi
 
@@ -158,7 +158,7 @@ kube::log::info_from_stdin() {
 # Print a status line.  Formatted to show up in a stream of output.
 kube::log::status() {
   local V="${V:-0}"
-  if [[ $KUBE_VERBOSE < $V ]]; then
+  if [[ ${KUBE_VERBOSE} < ${V} ]]; then
     return
   fi
 

hack/lib/protoc.sh

@@ -83,7 +83,7 @@ function kube::protoc::format() {
 function kube::protoc::diff() {
   local ret=0
   diff -I "gzipped FileDescriptorProto" -I "0x" -Naupr ${1} ${2} || ret=$?
-  if [[ $ret -ne 0 ]]; then
+  if [[ ${ret} -ne 0 ]]; then
     echo ${3}
     exit 1
   fi

hack/local-up-cluster.sh

@@ -129,7 +129,7 @@ fi
 
 # set feature gates if enable Pod priority and preemption
 if [ "${ENABLE_POD_PRIORITY_PREEMPTION}" == true ]; then
-    FEATURE_GATES="$FEATURE_GATES,PodPriority=true"
+    FEATURE_GATES="${FEATURE_GATES},PodPriority=true"
 fi
 
 # warn if users are running with swap allowed
@@ -169,15 +169,15 @@ function guess_built_binary_path {
 GO_OUT=${GO_OUT:-}
 while getopts "ho:O" OPTION
 do
-    case $OPTION in
+    case ${OPTION} in
         o)
             echo "skipping build"
-            GO_OUT="$OPTARG"
-            echo "using source $GO_OUT"
+            GO_OUT="${OPTARG}"
+            echo "using source ${GO_OUT}"
             ;;
         O)
             GO_OUT=$(guess_built_binary_path)
-            if [ "$GO_OUT" == "" ]; then
+            if [ "${GO_OUT}" == "" ]; then
                 echo "Could not guess the correct output directory to use."
                 exit 1
             fi
@@ -193,7 +193,7 @@ do
     esac
 done
 
-if [ "x$GO_OUT" == "x" ]; then
+if [ "x${GO_OUT}" == "x" ]; then
     make -C "${KUBE_ROOT}" WHAT="cmd/kubectl cmd/hyperkube"
 else
     echo "skipped the build."
@@ -263,20 +263,20 @@ function test_apiserver_off {
     # For the common local scenario, fail fast if server is already running.
     # this can happen if you run local-up-cluster.sh twice and kill etcd in between.
     if [[ "${API_PORT}" -gt "0" ]]; then
-        curl --silent -g $API_HOST:$API_PORT
+        curl --silent -g ${API_HOST}:${API_PORT}
         if [ ! $? -eq 0 ]; then
             echo "API SERVER insecure port is free, proceeding..."
         else
-            echo "ERROR starting API SERVER, exiting. Some process on $API_HOST is serving already on $API_PORT"
+            echo "ERROR starting API SERVER, exiting. Some process on ${API_HOST} is serving already on ${API_PORT}"
             exit 1
         fi
     fi
 
-    curl --silent -k -g $API_HOST:$API_SECURE_PORT
+    curl --silent -k -g ${API_HOST}:${API_SECURE_PORT}
     if [ ! $? -eq 0 ]; then
         echo "API SERVER secure port is free, proceeding..."
     else
-        echo "ERROR starting API SERVER, exiting. Some process on $API_HOST is serving already on $API_SECURE_PORT"
+        echo "ERROR starting API SERVER, exiting. Some process on ${API_HOST} is serving already on ${API_SECURE_PORT}"
         exit 1
     fi
 }
@@ -335,9 +335,9 @@ function detect_binary {
 
 cleanup_dockerized_kubelet()
 {
-  if [[ -e $KUBELET_CIDFILE ]]; then
-    docker kill $(<$KUBELET_CIDFILE) > /dev/null
-    rm -f $KUBELET_CIDFILE
+  if [[ -e ${KUBELET_CIDFILE} ]]; then
+    docker kill $(<${KUBELET_CIDFILE}) > /dev/null
+    rm -f ${KUBELET_CIDFILE}
 
     # Save the docker logs
     if [[ -f /var/log/docker.log ]]; then
@@ -367,7 +367,7 @@ cleanup()
   [[ -n "${CTLRMGR_PID-}" ]] && CTLRMGR_PIDS=$(pgrep -P ${CTLRMGR_PID} ; ps -o pid= -p ${CTLRMGR_PID})
   [[ -n "${CTLRMGR_PIDS-}" ]] && sudo kill ${CTLRMGR_PIDS} 2>/dev/null
 
-  if [[ -n "$DOCKERIZE_KUBELET" ]]; then
+  if [[ -n "${DOCKERIZE_KUBELET}" ]]; then
     cleanup_dockerized_kubelet
   else
     # Check if the kubelet is still running
@@ -404,7 +404,7 @@ function healthcheck {
     CTLRMGR_PID=
   fi
 
-  if [[ -n "$DOCKERIZE_KUBELET" ]]; then
+  if [[ -n "${DOCKERIZE_KUBELET}" ]]; then
     # TODO (https://github.com/kubernetes/kubernetes/issues/62474): check health also in this case
     :
   elif [[ -n "${KUBELET_PID-}" ]] && ! sudo kill -0 ${KUBELET_PID} 2>/dev/null; then
@@ -648,11 +648,11 @@ function start_controller_manager {
       --pvclaimbinder-sync-period="${CLAIM_BINDER_SYNC_PERIOD}" \
       --feature-gates="${FEATURE_GATES}" \
       ${cloud_config_arg} \
-      --kubeconfig "$CERT_DIR"/controller.kubeconfig \
+      --kubeconfig "${CERT_DIR}"/controller.kubeconfig \
       --use-service-account-credentials \
       --controllers="${KUBE_CONTROLLERS}" \
       --leader-elect=false \
-      --cert-dir="$CERT_DIR" \
+      --cert-dir="${CERT_DIR}" \
       --master="https://${API_HOST}:${API_SECURE_PORT}" >"${CTLRMGR_LOG}" 2>&1 &
     CTLRMGR_PID=$!
 }
@@ -680,7 +680,7 @@ function start_cloud_controller_manager {
       --feature-gates="${FEATURE_GATES}" \
       --cloud-provider=${CLOUD_PROVIDER} \
       --cloud-config=${CLOUD_CONFIG} \
-      --kubeconfig "$CERT_DIR"/controller.kubeconfig \
+      --kubeconfig "${CERT_DIR}"/controller.kubeconfig \
       --use-service-account-credentials \
       --leader-elect=false \
       --master="https://${API_HOST}:${API_SECURE_PORT}" >"${CLOUD_CTLRMGR_LOG}" 2>&1 &
@@ -763,7 +763,7 @@ function start_kubelet {
       --hostname-override="${HOSTNAME_OVERRIDE}"
       ${cloud_config_arg}
       --address="${KUBELET_HOST}"
-      --kubeconfig "$CERT_DIR"/kubelet.kubeconfig
+      --kubeconfig "${CERT_DIR}"/kubelet.kubeconfig
       --feature-gates="${FEATURE_GATES}"
       --cpu-cfs-quota="${CPU_CFS_QUOTA}"
       --enable-controller-attach-detach="${ENABLE_CONTROLLER_ATTACH_DETACH}"
@@ -782,7 +782,7 @@ function start_kubelet {
       ${net_plugin_args}
       ${container_runtime_endpoint_args}
       ${image_service_endpoint_args}
-      --port="$KUBELET_PORT"
+      --port="${KUBELET_PORT}"
       ${KUBELET_FLAGS}
     )
 
@@ -792,7 +792,7 @@ function start_kubelet {
     else
 
       # Build the hyperkube container image if necessary
-      if [[ -z "$KUBELET_IMAGE" && -n "$DOCKERIZE_KUBELET" ]]; then
+      if [[ -z "${KUBELET_IMAGE}" && -n "${DOCKERIZE_KUBELET}" ]]; then
         HYPERKUBE_BIN="${GO_OUT}/hyperkube" REGISTRY="k8s.gcr.io" VERSION="latest" make -C "${KUBE_ROOT}/cluster/images/hyperkube" build
         KUBELET_IMAGE="k8s.gcr.io/hyperkube-amd64:latest"
       fi
@@ -841,7 +841,7 @@ function start_kubelet {
         --pid=host \
         --privileged=true \
         -i \
-        --cidfile=$KUBELET_CIDFILE \
+        --cidfile=${KUBELET_CIDFILE} \
         "${KUBELET_IMAGE}" \
         /kubelet "${all_kubelet_flags[@]}" >"${KUBELET_LOG}" 2>&1 &
       # Get PID of kubelet container.
@@ -849,7 +849,7 @@ function start_kubelet {
         echo -n "Trying to get PID of kubelet container..."
         KUBELET_PID=$(docker inspect kubelet -f '{{.State.Pid}}' 2>/dev/null || true)
         if [[ -n ${KUBELET_PID} && ${KUBELET_PID} -gt 0 ]]; then
-            echo " ok, $KUBELET_PID."
+            echo " ok, ${KUBELET_PID}."
             break
         else
             echo " failed, retry in 1 second."
@@ -858,8 +858,8 @@ function start_kubelet {
       done
     fi
     # Quick check that kubelet is running.
-    if [ -n "$KUBELET_PID" ] && ps -p $KUBELET_PID > /dev/null; then
-      echo "kubelet ( $KUBELET_PID ) is running."
+    if [ -n "${KUBELET_PID}" ] && ps -p ${KUBELET_PID} > /dev/null; then
+      echo "kubelet ( ${KUBELET_PID} ) is running."
     else
       cat ${KUBELET_LOG} ; exit 1
     fi
@@ -882,7 +882,7 @@ EOF
       #   foo: true
       #   bar: false
       for gate in $(echo ${FEATURE_GATES} | tr ',' ' '); do
-        echo $gate | ${SED} -e 's/\(.*\)=\(.*\)/  \1: \2/'
+        echo ${gate} | ${SED} -e 's/\(.*\)=\(.*\)/  \1: \2/'
       done
     fi >>/tmp/kube-proxy.yaml
 
@@ -896,7 +896,7 @@ EOF
     ${CONTROLPLANE_SUDO} "${GO_OUT}/hyperkube" scheduler \
       --v=${LOG_LEVEL} \
       --leader-elect=false \
-      --kubeconfig "$CERT_DIR"/scheduler.kubeconfig \
+      --kubeconfig "${CERT_DIR}"/scheduler.kubeconfig \
       --feature-gates="${FEATURE_GATES}" \
       --master="https://${API_HOST}:${API_SECURE_PORT}" >"${SCHEDULER_LOG}" 2>&1 &
     SCHEDULER_PID=$!
@@ -947,17 +947,17 @@ function create_psp_policy {
 }
 
 function create_storage_class {
-    if [ -z "$CLOUD_PROVIDER" ]; then
+    if [ -z "${CLOUD_PROVIDER}" ]; then
         CLASS_FILE=${KUBE_ROOT}/cluster/addons/storage-class/local/default.yaml
     else
         CLASS_FILE=${KUBE_ROOT}/cluster/addons/storage-class/${CLOUD_PROVIDER}/default.yaml
     fi
 
-    if [ -e $CLASS_FILE ]; then
-        echo "Create default storage class for $CLOUD_PROVIDER"
-        ${KUBECTL} --kubeconfig="${CERT_DIR}/admin.kubeconfig" create -f $CLASS_FILE
+    if [ -e ${CLASS_FILE} ]; then
+        echo "Create default storage class for ${CLOUD_PROVIDER}"
+        ${KUBECTL} --kubeconfig="${CERT_DIR}/admin.kubeconfig" create -f ${CLASS_FILE}
     else
-        echo "No storage class available for $CLOUD_PROVIDER."
+        echo "No storage class available for ${CLOUD_PROVIDER}."
     fi
 }
 
@@ -1053,11 +1053,11 @@ kube::util::test_openssl_installed
 kube::util::ensure-cfssl
 
 ### IF the user didn't supply an output/ for the build... Then we detect.
-if [ "$GO_OUT" == "" ]; then
+if [ "${GO_OUT}" == "" ]; then
   detect_binary
 fi
 echo "Detected host and ready to start services.  Doing some housekeeping first..."
-echo "Using GO_OUT $GO_OUT"
+echo "Using GO_OUT ${GO_OUT}"
 KUBELET_CIDFILE=/tmp/kubelet.cid
 if [[ "${ENABLE_DAEMON}" = false ]]; then
   trap cleanup EXIT
@@ -1101,7 +1101,7 @@ if [[ -n "${PSP_ADMISSION}" && "${AUTHORIZATION_MODE}" = *RBAC* ]]; then
   create_psp_policy
 fi
 
-if [[ "$DEFAULT_STORAGE_CLASS" = "true" ]]; then
+if [[ "${DEFAULT_STORAGE_CLASS}" = "true" ]]; then
   create_storage_class
 fi
 

hack/make-rules/make-help.sh

@@ -28,15 +28,15 @@ CMD_FLAG=false
 PLUGIN_CMD_FLAG=false
 
 echo "--------------------------------------------------------------------------------"
-for tar in $ALL_TARGETS; do
-	for cmdtar in $CMD_TARGETS; do
-		if [ $tar = $cmdtar ]; then
-			if [ $CMD_FLAG = true ]; then
+for tar in ${ALL_TARGETS}; do
+	for cmdtar in ${CMD_TARGETS}; do
+		if [ ${tar} = ${cmdtar} ]; then
+			if [ ${CMD_FLAG} = true ]; then
 				continue 2;
 			fi
 
 			echo -e "${red}${CMD_TARGETS}${reset}"
-			make -C "${KUBE_ROOT}" $tar PRINT_HELP=y
+			make -C "${KUBE_ROOT}" ${tar} PRINT_HELP=y
 			echo "---------------------------------------------------------------------------------"
 
 			CMD_FLAG=true
@@ -45,6 +45,6 @@ for tar in $ALL_TARGETS; do
 	done
 
 	echo -e "${red}${tar}${reset}"
-	make -C "${KUBE_ROOT}" $tar PRINT_HELP=y
+	make -C "${KUBE_ROOT}" ${tar} PRINT_HELP=y
 	echo "---------------------------------------------------------------------------------"
 done

hack/make-rules/test-e2e-node.sh

@@ -37,20 +37,20 @@ system_spec_name=${SYSTEM_SPEC_NAME:-}
 
 # Parse the flags to pass to ginkgo
 ginkgoflags=""
-if [[ $parallelism > 1 ]]; then
-  ginkgoflags="$ginkgoflags -nodes=$parallelism "
+if [[ ${parallelism} > 1 ]]; then
+  ginkgoflags="${ginkgoflags} -nodes=${parallelism} "
 fi
 
-if [[ $focus != "" ]]; then
-  ginkgoflags="$ginkgoflags -focus=\"$focus\" "
+if [[ ${focus} != "" ]]; then
+  ginkgoflags="${ginkgoflags} -focus=\"${focus}\" "
 fi
 
-if [[ $skip != "" ]]; then
-  ginkgoflags="$ginkgoflags -skip=\"$skip\" "
+if [[ ${skip} != "" ]]; then
+  ginkgoflags="${ginkgoflags} -skip=\"${skip}\" "
 fi
 
-if [[ $run_until_failure != "" ]]; then
-  ginkgoflags="$ginkgoflags -untilItFails=$run_until_failure "
+if [[ ${run_until_failure} != "" ]]; then
+  ginkgoflags="${ginkgoflags} -untilItFails=${run_until_failure} "
 fi
 
 # Setup the directory to copy test artifacts (logs, junit.xml, etc) from remote host to local host
@@ -60,34 +60,34 @@ if [ ! -d "${artifacts}" ]; then
 fi
 echo "Test artifacts will be written to ${artifacts}"
 
-if [[ $runtime == "remote" ]] ; then
-  if [[ ! -z $container_runtime_endpoint ]] ; then
-    test_args="--container-runtime-endpoint=${container_runtime_endpoint} $test_args"
+if [[ ${runtime} == "remote" ]] ; then
+  if [[ ! -z ${container_runtime_endpoint} ]] ; then
+    test_args="--container-runtime-endpoint=${container_runtime_endpoint} ${test_args}"
   fi
-  if [[ ! -z $image_service_endpoint ]] ; then
-    test_args="--image-service-endpoint=$image_service_endpoint $test_args"
+  if [[ ! -z ${image_service_endpoint} ]] ; then
+    test_args="--image-service-endpoint=${image_service_endpoint} ${test_args}"
   fi
 fi
 
 
-if [ $remote = true ] ; then
+if [ ${remote} = true ] ; then
   # The following options are only valid in remote run.
   images=${IMAGES:-""}
   hosts=${HOSTS:-""}
   image_project=${IMAGE_PROJECT:-"kubernetes-node-e2e-images"}
   metadata=${INSTANCE_METADATA:-""}
   list_images=${LIST_IMAGES:-false}
-  if  [[ $list_images == "true" ]]; then
+  if  [[ ${list_images} == "true" ]]; then
     gcloud compute images list --project="${image_project}" | grep "e2e-node"
     exit 0
   fi
   gubernator=${GUBERNATOR:-"false"}
   image_config_file=${IMAGE_CONFIG_FILE:-""}
-  if [[ $hosts == "" && $images == "" && $image_config_file == "" ]]; then
+  if [[ ${hosts} == "" && ${images} == "" && ${image_config_file} == "" ]]; then
     image_project=${IMAGE_PROJECT:-"cos-cloud"}
-    gci_image=$(gcloud compute images list --project $image_project \
+    gci_image=$(gcloud compute images list --project ${image_project} \
     --no-standard-images --filter="name ~ 'cos-beta.*'" --format="table[no-heading](name)")
-    images=$gci_image
+    images=${gci_image}
     metadata="user-data<${KUBE_ROOT}/test/e2e_node/jenkins/gci-init.yaml,gci-update-strategy=update_disabled"
   fi
   instance_prefix=${INSTANCE_PREFIX:-"test"}
@@ -97,58 +97,58 @@ if [ $remote = true ] ; then
 
   # Get the compute zone
   zone=${ZONE:-"$(gcloud info --format='value(config.properties.compute.zone)')"}
-  if [[ $zone == "" ]]; then
+  if [[ ${zone} == "" ]]; then
     echo "Could not find gcloud compute/zone when running: \`gcloud info --format='value(config.properties.compute.zone)'\`"
     exit 1
   fi
 
   # Get the compute project
   project=$(gcloud info --format='value(config.project)')
-  if [[ $project == "" ]]; then
+  if [[ ${project} == "" ]]; then
     echo "Could not find gcloud project when running: \`gcloud info --format='value(config.project)'\`"
     exit 1
   fi
 
   # Check if any of the images specified already have running instances.  If so reuse those instances
   # by moving the IMAGE to a HOST
-  if [[ $images != "" ]]; then
-  IFS=',' read -ra IM <<< "$images"
+  if [[ ${images} != "" ]]; then
+  IFS=',' read -ra IM <<< "${images}"
        images=""
        for i in "${IM[@]}"; do
-         if [[ $(gcloud compute instances list "${instance_prefix}-$i" | grep $i) ]]; then
-           if [[ $hosts != "" ]]; then
-             hosts="$hosts,"
+         if [[ $(gcloud compute instances list "${instance_prefix}-$i" | grep ${i}) ]]; then
+           if [[ ${hosts} != "" ]]; then
+             hosts="${hosts},"
            fi
            echo "Reusing host ${instance_prefix}-$i"
            hosts="${hosts}${instance_prefix}-${i}"
          else
-           if [[ $images != "" ]]; then
-             images="$images,"
+           if [[ ${images} != "" ]]; then
+             images="${images},"
            fi
-           images="$images$i"
+           images="${images}${i}"
          fi
        done
   fi
 
   # Output the configuration we will try to run
   echo "Running tests remotely using"
-  echo "Project: $project"
-  echo "Image Project: $image_project"
-  echo "Compute/Zone: $zone"
-  echo "Images: $images"
-  echo "Hosts: $hosts"
-  echo "Ginkgo Flags: $ginkgoflags"
-  echo "Instance Metadata: $metadata"
-  echo "Image Config File: $image_config_file"
+  echo "Project: ${project}"
+  echo "Image Project: ${image_project}"
+  echo "Compute/Zone: ${zone}"
+  echo "Images: ${images}"
+  echo "Hosts: ${hosts}"
+  echo "Ginkgo Flags: ${ginkgoflags}"
+  echo "Instance Metadata: ${metadata}"
+  echo "Image Config File: ${image_config_file}"
   # Invoke the runner
   go run test/e2e_node/runner/remote/run_remote.go  --logtostderr --vmodule=*=4 --ssh-env="gce" \
-    --zone="$zone" --project="$project" --gubernator="$gubernator" \
-    --hosts="$hosts" --images="$images" --cleanup="$cleanup" \
-    --results-dir="$artifacts" --ginkgo-flags="$ginkgoflags" \
-    --image-project="$image_project" --instance-name-prefix="$instance_prefix" \
-    --delete-instances="$delete_instances" --test_args="$test_args" --instance-metadata="$metadata" \
-    --image-config-file="$image_config_file" --system-spec-name="$system_spec_name" \
-    --test-suite="$test_suite" \
+    --zone="${zone}" --project="${project}" --gubernator="${gubernator}" \
+    --hosts="${hosts}" --images="${images}" --cleanup="${cleanup}" \
+    --results-dir="${artifacts}" --ginkgo-flags="${ginkgoflags}" \
+    --image-project="${image_project}" --instance-name-prefix="${instance_prefix}" \
+    --delete-instances="${delete_instances}" --test_args="${test_args}" --instance-metadata="${metadata}" \
+    --image-config-file="${image_config_file}" --system-spec-name="${system_spec_name}" \
+    --test-suite="${test_suite}" \
     2>&1 | tee -i "${artifacts}/build-log.txt"
   exit $?
 
@@ -161,10 +161,10 @@ else
 
   # Do not use any network plugin by default. User could override the flags with
   # test_args.
-  test_args='--kubelet-flags="--network-plugin= --cni-bin-dir=" '$test_args
+  test_args='--kubelet-flags="--network-plugin= --cni-bin-dir=" '${test_args}
 
   # Runtime flags
-  test_args='--kubelet-flags="--container-runtime='$runtime'" '$test_args
+  test_args='--kubelet-flags="--container-runtime='${runtime}'" '${test_args}
 
   # Test using the host the script was run on
   # Provided for backwards compatibility
@@ -172,6 +172,6 @@ else
     --system-spec-name="$system_spec_name" --ginkgo-flags="$ginkgoflags" \
     --test-flags="--container-runtime=${runtime} \
     --alsologtostderr --v 4 --report-dir=${artifacts} --node-name $(hostname) \
-    $test_args" --build-dependencies=true 2>&1 | tee -i "${artifacts}/build-log.txt"
+    ${test_args}" --build-dependencies=true 2>&1 | tee -i "${artifacts}/build-log.txt"
   exit $?
 fi

hack/make-rules/test.sh

@@ -143,7 +143,7 @@ isnum() {
 
 PARALLEL="${PARALLEL:-1}"
 while getopts "hp:i:" opt ; do
-  case $opt in
+  case ${opt} in
     h)
       kube::test::usage
       exit 0
@@ -316,12 +316,12 @@ runTests() {
   # vendor/k8s.io/client-go/1.4/rest: causes cover internal errors
   #                            https://github.com/golang/go/issues/16540
   cover_ignore_dirs="vendor/k8s.io/code-generator/cmd/generator|vendor/k8s.io/client-go/1.4/rest"
-  for path in $(echo $cover_ignore_dirs | sed 's/|/ /g'); do
+  for path in $(echo ${cover_ignore_dirs} | sed 's/|/ /g'); do
       echo -e "skipped\tk8s.io/kubernetes/$path"
   done
 
   printf "%s\n" "${@}" \
-    | grep -Ev $cover_ignore_dirs \
+    | grep -Ev ${cover_ignore_dirs} \
     | xargs -I{} -n 1 -P ${KUBE_COVERPROCS} \
     bash -c "set -o pipefail; _pkg=\"\$0\"; _pkg_out=\${_pkg//\//_}; \
       go test ${goflags[@]:+${goflags[@]}} \
@@ -349,7 +349,7 @@ runTests() {
     # Include all coverage reach data in the combined profile, but exclude the
     # 'mode' lines, as there should be only one.
     for x in `find "${cover_report_dir}" -name "${cover_profile}"`; do
-      cat $x | grep -h -v "^mode:" || true
+      cat ${x} | grep -h -v "^mode:" || true
     done
   } >"${COMBINED_COVER_PROFILE}"
 
@@ -374,8 +374,8 @@ checkFDs() {
   # several unittests panic when httptest cannot open more sockets
   # due to the low default files limit on OS X.  Warn about low limit.
   local fileslimit="$(ulimit -n)"
-  if [[ $fileslimit -lt 1000 ]]; then
-    echo "WARNING: ulimit -n (files) should be at least 1000, is $fileslimit, may cause test failure";
+  if [[ ${fileslimit} -lt 1000 ]]; then
+    echo "WARNING: ulimit -n (files) should be at least 1000, is ${fileslimit}, may cause test failure";
   fi
 }
 
@@ -387,7 +387,7 @@ IFS=';' read -a apiVersions <<< "${KUBE_TEST_API_VERSIONS}"
 apiVersionsCount=${#apiVersions[@]}
 for (( i=0; i<${apiVersionsCount}; i++ )); do
   apiVersion=${apiVersions[i]}
-  echo "Running tests for APIVersion: $apiVersion"
+  echo "Running tests for APIVersion: ${apiVersion}"
   # KUBE_TEST_API sets the version of each group to be tested.
   KUBE_TEST_API="${apiVersion}" runTests "$@"
 done

hack/update-gofmt.sh

@@ -44,4 +44,4 @@ find_files() {
 }
 
 GOFMT="gofmt -s -w"
-find_files | xargs $GOFMT
+find_files | xargs ${GOFMT}