vendor updates

2025-06-13 18:43:34 +00:00 · 2018-03-06 17:33:18 -05:00
parent 4b3ebc171b
commit e9033989a0
5854 changed files with 248382 additions and 119809 deletions
--- a/vendor/k8s.io/kubernetes/hack/lib/BUILD
+++ b/vendor/k8s.io/kubernetes/hack/lib/BUILD
@ -6,14 +6,12 @@ sh_library(
        "etcd.sh",
        "golang.sh",
        "init.sh",
+        "logging.sh",
        "swagger.sh",
        "test.sh",
        "util.sh",
        "version.sh",
    ],
-    deps = [
-        "//cluster/lib",
-    ],
 )

 filegroup(
--- a/vendor/k8s.io/kubernetes/hack/lib/etcd.sh
+++ b/vendor/k8s.io/kubernetes/hack/lib/etcd.sh
@ -16,21 +16,30 @@

 # A set of helpers for starting/running etcd for tests

-ETCD_VERSION=${ETCD_VERSION:-3.1.10}
+ETCD_VERSION=${ETCD_VERSION:-3.2.14}
 ETCD_HOST=${ETCD_HOST:-127.0.0.1}
 ETCD_PORT=${ETCD_PORT:-2379}

 kube::etcd::validate() {
  # validate if in path
-  which etcd >/dev/null || {
+  command -v etcd >/dev/null || {
    kube::log::usage "etcd must be in your PATH"
    exit 1
  }

-  # validate it is not running
-  if pgrep -x etcd >/dev/null 2>&1; then
-    kube::log::usage "etcd appears to already be running on this machine (`pgrep -xl etcd`) (or its a zombie and you need to kill its parent)."
-    kube::log::usage "retry after you resolve this etcd error."
+  # validate etcd port is free
+  local port_check_command
+  if command -v ss &> /dev/null && ss -Version | grep 'iproute2' &> /dev/null; then
+    port_check_command="ss"
+  elif command -v netstat &>/dev/null; then
+    port_check_command="netstat"
+  else
+    kube::log::usage "unable to identify if etcd is bound to port ${ETCD_PORT}. unable to find ss or netstat utilities."
+    exit 1
+  fi
+  if ${port_check_command} -nat | grep "LISTEN" | grep "[\.:]${ETCD_PORT:?}" >/dev/null 2>&1; then
+    kube::log::usage "unable to start etcd as port ${ETCD_PORT} is in use. please stop the process listening on this port and retry."
+    kube::log::usage "`netstat -nat | grep "[\.:]${ETCD_PORT:?} .*LISTEN"`"
    exit 1
  fi

@ -74,12 +83,16 @@ kube::etcd::start() {
 }

 kube::etcd::stop() {
-  kill "${ETCD_PID-}" >/dev/null 2>&1 || :
-  wait "${ETCD_PID-}" >/dev/null 2>&1 || :
+  if [[ -n "${ETCD_PID-}" ]]; then
+    kill "${ETCD_PID}" &>/dev/null || :
+    wait "${ETCD_PID}" &>/dev/null || :
+  fi
 }

 kube::etcd::clean_etcd_dir() {
-  rm -rf "${ETCD_DIR-}"
+  if [[ -n "${ETCD_DIR-}" ]]; then
+    rm -rf "${ETCD_DIR}"
+  fi
 }

 kube::etcd::cleanup() {
--- a/vendor/k8s.io/kubernetes/hack/lib/golang.sh
+++ b/vendor/k8s.io/kubernetes/hack/lib/golang.sh
@ -29,15 +29,16 @@ kube::golang::server_targets() {
    cmd/kubelet
    cmd/kubeadm
    cmd/hyperkube
+    cmd/kube-scheduler
    vendor/k8s.io/kube-aggregator
    vendor/k8s.io/apiextensions-apiserver
-    plugin/cmd/kube-scheduler
    cluster/gce/gci/mounter
  )
  echo "${targets[@]}"
 }

-readonly KUBE_SERVER_TARGETS=($(kube::golang::server_targets))
+IFS=" " read -ra KUBE_SERVER_TARGETS <<< "$(kube::golang::server_targets)"
+readonly KUBE_SERVER_TARGETS
 readonly KUBE_SERVER_BINARIES=("${KUBE_SERVER_TARGETS[@]##*/}")

 # The set of server targets that we are only building for Kubernetes nodes
@ -51,15 +52,20 @@ kube::golang::node_targets() {
  echo "${targets[@]}"
 }

-readonly KUBE_NODE_TARGETS=($(kube::golang::node_targets))
+IFS=" " read -ra KUBE_NODE_TARGETS <<< "$(kube::golang::node_targets)"
+readonly KUBE_NODE_TARGETS
 readonly KUBE_NODE_BINARIES=("${KUBE_NODE_TARGETS[@]##*/}")
 readonly KUBE_NODE_BINARIES_WIN=("${KUBE_NODE_BINARIES[@]/%/.exe}")

 if [[ -n "${KUBE_BUILD_PLATFORMS:-}" ]]; then
-  readonly KUBE_SERVER_PLATFORMS=(${KUBE_BUILD_PLATFORMS})
-  readonly KUBE_NODE_PLATFORMS=(${KUBE_BUILD_PLATFORMS})
-  readonly KUBE_TEST_PLATFORMS=(${KUBE_BUILD_PLATFORMS})
-  readonly KUBE_CLIENT_PLATFORMS=(${KUBE_BUILD_PLATFORMS})
+  IFS=" " read -ra KUBE_SERVER_PLATFORMS <<< "$KUBE_BUILD_PLATFORMS"
+  IFS=" " read -ra KUBE_NODE_PLATFORMS <<< "$KUBE_BUILD_PLATFORMS"
+  IFS=" " read -ra KUBE_TEST_PLATFORMS <<< "$KUBE_BUILD_PLATFORMS"
+  IFS=" " read -ra KUBE_CLIENT_PLATFORMS <<< "$KUBE_BUILD_PLATFORMS"
+  readonly KUBE_SERVER_PLATFORMS
+  readonly KUBE_NODE_PLATFORMS
+  readonly KUBE_TEST_PLATFORMS
+  readonly KUBE_CLIENT_PLATFORMS
 elif [[ "${KUBE_FASTBUILD:-}" == "true" ]]; then
  readonly KUBE_SERVER_PLATFORMS=(linux/amd64)
  readonly KUBE_NODE_PLATFORMS=(linux/amd64)
@ -146,7 +152,8 @@ kube::golang::test_targets() {
  )
  echo "${targets[@]}"
 }
-readonly KUBE_TEST_TARGETS=($(kube::golang::test_targets))
+IFS=" " read -ra KUBE_TEST_TARGETS <<< "$(kube::golang::test_targets)"
+readonly KUBE_TEST_TARGETS
 readonly KUBE_TEST_BINARIES=("${KUBE_TEST_TARGETS[@]##*/}")
 readonly KUBE_TEST_BINARIES_WIN=("${KUBE_TEST_BINARIES[@]/%/.exe}")
 # If you update this list, please also update build/BUILD.
@ -177,24 +184,21 @@ kube::golang::server_test_targets() {
  echo "${targets[@]}"
 }

-readonly KUBE_TEST_SERVER_TARGETS=($(kube::golang::server_test_targets))
+IFS=" " read -ra KUBE_TEST_SERVER_TARGETS <<< "$(kube::golang::server_test_targets)"
+readonly KUBE_TEST_SERVER_TARGETS
 readonly KUBE_TEST_SERVER_BINARIES=("${KUBE_TEST_SERVER_TARGETS[@]##*/}")
 readonly KUBE_TEST_SERVER_PLATFORMS=("${KUBE_SERVER_PLATFORMS[@]}")

-# Gigabytes desired for parallel platform builds. 11 is fairly
-# arbitrary, but is a reasonable splitting point for 2015
-# laptops-versus-not.
-readonly KUBE_PARALLEL_BUILD_MEMORY=11
+# Gigabytes necessary for parallel platform builds.
+# As of January 2018, RAM usage is exceeding 30G
+# Setting to 40 to provide some headroom
+readonly KUBE_PARALLEL_BUILD_MEMORY=40

-# TODO(pipejakob) gke-certificates-controller is included here to exercise its
-# compilation, but it doesn't need to be distributed in any of our tars. Its
-# code is only living in this repo temporarily until it finds a new home.
 readonly KUBE_ALL_TARGETS=(
  "${KUBE_SERVER_TARGETS[@]}"
  "${KUBE_CLIENT_TARGETS[@]}"
  "${KUBE_TEST_TARGETS[@]}"
  "${KUBE_TEST_SERVER_TARGETS[@]}"
-  cmd/gke-certificates-controller
 )
 readonly KUBE_ALL_BINARIES=("${KUBE_ALL_TARGETS[@]##*/}")

@ -320,10 +324,10 @@ EOF
  fi

  local go_version
-  go_version=($(go version))
+  IFS=" " read -ra go_version <<< "$(go version)"
  local minimum_go_version
  minimum_go_version=go1.9.1
-  if [[ "${go_version[2]}" < "${minimum_go_version}" && "${go_version[2]}" != "devel" ]]; then
+  if [[ "${minimum_go_version}" != $(echo -e "${minimum_go_version}\n${go_version[2]}" | sort -s -t. -k 1,1 -k 2,2n -k 3,3n | head -n1) && "${go_version[2]}" != "devel" ]]; then
    kube::log::usage_from_stdin <<EOF
 Detected go version: ${go_version[*]}.
 Kubernetes requires ${minimum_go_version} or greater.
@ -397,7 +401,7 @@ kube::golang::place_bins() {
    # The substitution on platform_src below will replace all slashes with
    # underscores.  It'll transform darwin/amd64 -> darwin_amd64.
    local platform_src="/${platform//\//_}"
-    if [[ $platform == $host_platform ]]; then
+    if [[ "$platform" == "$host_platform" ]]; then
      platform_src=""
      rm -f "${THIS_PLATFORM_BIN}"
      ln -s "${KUBE_OUTPUT_BINPATH}/${platform}" "${THIS_PLATFORM_BIN}"
@ -461,7 +465,7 @@ kube::golang::output_filename_for_binary() {
  local binary=$1
  local platform=$2
  local output_path="${KUBE_GOPATH}/bin"
-  if [[ $platform != $host_platform ]]; then
+  if [[ "$platform" != "$host_platform" ]]; then
    output_path="${output_path}/${platform//\//_}"
  fi
  local bin=$(basename "${binary}")
@ -644,7 +648,8 @@ kube::golang::build_binaries() {
      targets=("${KUBE_ALL_TARGETS[@]}")
    fi

-    local -a platforms=(${KUBE_BUILD_PLATFORMS:-})
+    local -a platforms
+    IFS=" " read -ra platforms <<< "${KUBE_BUILD_PLATFORMS:-}"
    if [[ ${#platforms[@]} -eq 0 ]]; then
      platforms=("${host_platform}")
    fi
@ -670,7 +675,7 @@ kube::golang::build_binaries() {
    kube::golang::build_kube_toolchain

    kube::log::status "Generating bindata:" "${KUBE_BINDATAS[@]}"
-    for bindata in ${KUBE_BINDATAS[@]}; do
+    for bindata in "${KUBE_BINDATAS[@]}"; do
      # Only try to generate bindata if the file exists, since in some cases
      # one-off builds of individual directories may exclude some files.
      if [[ -f "${KUBE_ROOT}/${bindata}" ]]; then
--- a/vendor/k8s.io/kubernetes/hack/lib/init.sh
+++ b/vendor/k8s.io/kubernetes/hack/lib/init.sh
@ -18,6 +18,10 @@ set -o errexit
 set -o nounset
 set -o pipefail

+# Unset CDPATH so that path interpolation can work correctly
+# https://github.com/kubernetes/kubernetes/issues/52255
+unset CDPATH
+
 # The root of the build/dist directory
 KUBE_ROOT="$(cd "$(dirname "${BASH_SOURCE}")/../.." && pwd -P)"

@ -37,7 +41,7 @@ export no_proxy=127.0.0.1,localhost
 THIS_PLATFORM_BIN="${KUBE_ROOT}/_output/bin"

 source "${KUBE_ROOT}/hack/lib/util.sh"
-source "${KUBE_ROOT}/cluster/lib/logging.sh"
+source "${KUBE_ROOT}/hack/lib/logging.sh"

 kube::log::install_errexit

@ -127,7 +131,7 @@ function kube::readlinkdashf {
      cd "$1"
      pwd -P
    else
-      cd $(dirname "$1")
+      cd "$(dirname "$1")"
      local f
      f=$(basename "$1")
      if [[ -L "$f" ]]; then
--- a/vendor/k8s.io/kubernetes/hack/lib/logging.sh
+++ b/vendor/k8s.io/kubernetes/hack/lib/logging.sh
@ -0,0 +1,171 @@
+#!/bin/bash
+
+# Copyright 2014 The Kubernetes Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Controls verbosity of the script output and logging.
+KUBE_VERBOSE="${KUBE_VERBOSE:-5}"
+
+# Handler for when we exit automatically on an error.
+# Borrowed from https://gist.github.com/ahendrix/7030300
+kube::log::errexit() {
+  local err="${PIPESTATUS[@]}"
+
+  # If the shell we are in doesn't have errexit set (common in subshells) then
+  # don't dump stacks.
+  set +o | grep -qe "-o errexit" || return
+
+  set +o xtrace
+  local code="${1:-1}"
+  # Print out the stack trace described by $function_stack  
+  if [ ${#FUNCNAME[@]} -gt 2 ]
+  then
+    kube::log::error "Call tree:"
+    for ((i=1;i<${#FUNCNAME[@]}-1;i++))
+    do
+      kube::log::error " $i: ${BASH_SOURCE[$i+1]}:${BASH_LINENO[$i]} ${FUNCNAME[$i]}(...)"
+    done
+  fi  
+  kube::log::error_exit "Error in ${BASH_SOURCE[1]}:${BASH_LINENO[0]}. '${BASH_COMMAND}' exited with status $err" "${1:-1}" 1
+}
+
+kube::log::install_errexit() {
+  # trap ERR to provide an error handler whenever a command exits nonzero  this
+  # is a more verbose version of set -o errexit
+  trap 'kube::log::errexit' ERR
+
+  # setting errtrace allows our ERR trap handler to be propagated to functions,
+  # expansions and subshells
+  set -o errtrace
+}
+
+# Print out the stack trace
+#
+# Args:
+#   $1 The number of stack frames to skip when printing.
+kube::log::stack() {
+  local stack_skip=${1:-0}
+  stack_skip=$((stack_skip + 1))
+  if [[ ${#FUNCNAME[@]} -gt $stack_skip ]]; then
+    echo "Call stack:" >&2
+    local i
+    for ((i=1 ; i <= ${#FUNCNAME[@]} - $stack_skip ; i++))
+    do
+      local frame_no=$((i - 1 + stack_skip))
+      local source_file=${BASH_SOURCE[$frame_no]}
+      local source_lineno=${BASH_LINENO[$((frame_no - 1))]}
+      local funcname=${FUNCNAME[$frame_no]}
+      echo "  $i: ${source_file}:${source_lineno} ${funcname}(...)" >&2
+    done
+  fi
+}
+
+# Log an error and exit.
+# Args:
+#   $1 Message to log with the error
+#   $2 The error code to return
+#   $3 The number of stack frames to skip when printing.
+kube::log::error_exit() {
+  local message="${1:-}"
+  local code="${2:-1}"
+  local stack_skip="${3:-0}"
+  stack_skip=$((stack_skip + 1))
+
+  if [[ ${KUBE_VERBOSE} -ge 4 ]]; then
+    local source_file=${BASH_SOURCE[$stack_skip]}
+    local source_line=${BASH_LINENO[$((stack_skip - 1))]}
+    echo "!!! Error in ${source_file}:${source_line}" >&2
+    [[ -z ${1-} ]] || {
+      echo "  ${1}" >&2
+    }
+
+    kube::log::stack $stack_skip
+
+    echo "Exiting with status ${code}" >&2
+  fi
+
+  exit "${code}"
+}
+
+# Log an error but keep going.  Don't dump the stack or exit.
+kube::log::error() {
+  timestamp=$(date +"[%m%d %H:%M:%S]")
+  echo "!!! $timestamp ${1-}" >&2
+  shift
+  for message; do
+    echo "    $message" >&2
+  done
+}
+
+# Print an usage message to stderr.  The arguments are printed directly.
+kube::log::usage() {
+  echo >&2
+  local message
+  for message; do
+    echo "$message" >&2
+  done
+  echo >&2
+}
+
+kube::log::usage_from_stdin() {
+  local messages=()
+  while read -r line; do
+    messages+=("$line")
+  done
+
+  kube::log::usage "${messages[@]}"
+}
+
+# Print out some info that isn't a top level status line
+kube::log::info() {
+  local V="${V:-0}"
+  if [[ $KUBE_VERBOSE < $V ]]; then
+    return
+  fi
+
+  for message; do
+    echo "$message"
+  done
+}
+
+# Just like kube::log::info, but no \n, so you can make a progress bar
+kube::log::progress() {
+  for message; do
+    echo -e -n "$message"
+  done
+}
+
+kube::log::info_from_stdin() {
+  local messages=()
+  while read -r line; do
+    messages+=("$line")
+  done
+
+  kube::log::info "${messages[@]}"
+}
+
+# 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
+    return
+  fi
+
+  timestamp=$(date +"[%m%d %H:%M:%S]")
+  echo "+++ $timestamp $1"
+  shift
+  for message; do
+    echo "    $message"
+  done
+}
--- a/vendor/k8s.io/kubernetes/hack/lib/protoc.sh
+++ b/vendor/k8s.io/kubernetes/hack/lib/protoc.sh
@ -57,7 +57,7 @@ function kube::protoc::check_protoc() {
 # $1: Full path to the directory where the api.proto file is
 function kube::protoc::protoc() {
  local package=${1}
-  gogopath=$(dirname $(kube::util::find-binary "protoc-gen-gogo"))
+  gogopath=$(dirname "$(kube::util::find-binary "protoc-gen-gogo")")

  PATH="${gogopath}:${PATH}" protoc \
    --proto_path="${package}" \
--- a/vendor/k8s.io/kubernetes/hack/lib/swagger.sh
+++ b/vendor/k8s.io/kubernetes/hack/lib/swagger.sh
@ -117,7 +117,7 @@ kube::swagger::gen_api_ref_docs() {
      -v "${swagger_spec_path}":/swagger-source:z \
      -v "${register_file}":/register.go:z \
      --net=host -e "https_proxy=${KUBERNETES_HTTPS_PROXY:-}" \
-      gcr.io/google_containers/gen-swagger-docs:v8 \
+      k8s.gcr.io/gen-swagger-docs:v8 \
      "${swagger_json_name}"
  done

--- a/vendor/k8s.io/kubernetes/hack/lib/test.sh
+++ b/vendor/k8s.io/kubernetes/hack/lib/test.sh
@ -265,7 +265,7 @@ kube::test::if_has_string() {
  local message=$1
  local match=$2

-  if echo "$message" | grep -q "$match"; then
+  if grep -q "${match}" <<< "${message}"; then
    echo "Successful"
    echo "message:$message"
    echo "has:$match"
@ -283,7 +283,7 @@ kube::test::if_has_not_string() {
  local message=$1
  local match=$2

-  if echo "$message" | grep -q "$match"; then
+  if grep -q "${match}" <<< "${message}"; then
    echo "FAIL!"
    echo "message:$message"
    echo "has:$match"
--- a/vendor/k8s.io/kubernetes/hack/lib/util.sh
+++ b/vendor/k8s.io/kubernetes/hack/lib/util.sh
@ -30,13 +30,13 @@ kube::util::wait_for_url() {
  }

  local i
-  for i in $(seq 1 $times); do
+  for i in $(seq 1 "$times"); do
    local out
-    if out=$(curl --max-time 1 -gkfs $url 2>/dev/null); then
+    if out=$(curl --max-time 1 -gkfs "$url" 2>/dev/null); then
      kube::log::status "On try ${i}, ${prefix}: ${out}"
      return 0
    fi
-    sleep ${wait}
+    sleep "${wait}"
  done
  kube::log::error "Timed out waiting for ${prefix} to answer at ${url}; tried ${times} waiting ${wait} between each"
  return 1
@ -148,10 +148,11 @@ kube::util::find-binary-for-platform() {
    "${KUBE_ROOT}/platforms/${platform}/${lookfor}"
  )
  # Also search for binary in bazel build tree.
-  # In some cases we have to name the binary $BINARY_bin, since there was a
-  # directory named $BINARY next to it.
+  # The bazel go rules place binaries in subtrees like
+  # "bazel-bin/source/path/linux_amd64_pure_stripped/binaryname", so make sure
+  # the platform name is matched in the path.
  locations+=($(find "${KUBE_ROOT}/bazel-bin/" -type f -executable \
-    \( -name "${lookfor}" -o -name "${lookfor}_bin" \) 2>/dev/null || true) )
+    -path "*/${platform/\//_}*/${lookfor}" 2>/dev/null || true) )

  # List most recently-updated location.
  local -r bin=$( (ls -t "${locations[@]}" 2>/dev/null || true) | head -1 )
@ -208,7 +209,7 @@ kube::util::gen-docs() {
 # Puts a placeholder for every generated doc. This makes the link checker work.
 kube::util::set-placeholder-gen-docs() {
  local list_file="${KUBE_ROOT}/docs/.generated_docs"
-  if [ -e ${list_file} ]; then
+  if [[ -e "${list_file}" ]]; then
    # remove all of the old docs; we don't want to check them in.
    while read file; do
      if [[ "${list_file}" != "${KUBE_ROOT}/${file}" ]]; then
@ -243,11 +244,9 @@ kube::util::remove-gen-docs() {
 kube::util::group-version-to-pkg-path() {
  staging_apis=(
  $(
-    pushd ${KUBE_ROOT}/staging/src/k8s.io/api > /dev/null
-      find . -name types.go | xargs -n1 dirname | sed "s|\./||g" | sort
-    popd > /dev/null
-  )
-  )
+    cd "${KUBE_ROOT}/staging/src/k8s.io/api" &&
+    find . -name types.go -exec dirname {} \; | sed "s|\./||g" | sort
+  ))

  local group_version="$1"

@ -273,14 +272,8 @@ kube::util::group-version-to-pkg-path() {
    meta/v1)
      echo "vendor/k8s.io/apimachinery/pkg/apis/meta/v1"
      ;;
-    meta/v1)
-      echo "../vendor/k8s.io/apimachinery/pkg/apis/meta/v1"
-      ;;
-    meta/v1alpha1)
-      echo "vendor/k8s.io/apimachinery/pkg/apis/meta/v1alpha1"
-      ;;
-    meta/v1alpha1)
-      echo "../vendor/k8s.io/apimachinery/pkg/apis/meta/v1alpha1"
+    meta/v1beta1)
+      echo "vendor/k8s.io/apimachinery/pkg/apis/meta/v1beta1"
      ;;
    unversioned)
      echo "pkg/api/unversioned"
@ -445,6 +438,9 @@ kube::util::ensure_godep_version() {

  kube::log::status "Installing godep version ${GODEP_VERSION}"
  go install ./vendor/github.com/tools/godep/
+  GP="$(echo $GOPATH | cut -f1 -d:)"
+  hash -r # force bash to clear PATH cache
+  PATH="${GP}/bin:${PATH}"

  if [[ "$(godep version 2>/dev/null)" != *"godep ${GODEP_VERSION}"* ]]; then
    kube::log::error "Expected godep ${GODEP_VERSION}, got $(godep version)"
@ -457,7 +453,12 @@ kube::util::ensure_godep_version() {
 kube::util::ensure_no_staging_repos_in_gopath() {
  kube::util::ensure_single_dir_gopath
  local error=0
-  for repo in $(ls ${KUBE_ROOT}/staging/src/k8s.io); do
+  for repo_file in "${KUBE_ROOT}"/staging/src/k8s.io/*; do
+    if [[ ! -d "$repo_file" ]]; then
+      # not a directory or there were no files
+      continue;
+    fi
+    repo="$(basename "$repo_file")"
    if [ -e "${GOPATH}/src/k8s.io/${repo}" ]; then
      echo "k8s.io/${repo} exists in GOPATH. Remove before running godep-save.sh." 1>&2
      error=1
--- a/vendor/k8s.io/kubernetes/hack/lib/version.sh
+++ b/vendor/k8s.io/kubernetes/hack/lib/version.sh
@ -62,7 +62,7 @@ kube::version::get_version_vars() {
      fi
    fi

-    # Use git describe to find the version based on annotated tags.
+    # Use git describe to find the version based on tags.
    if [[ -n ${KUBE_GIT_VERSION-} ]] || KUBE_GIT_VERSION=$("${git[@]}" describe --tags --abbrev=14 "${KUBE_GIT_COMMIT}^{commit}" 2>/dev/null); then
      # This translates the "git describe" to an actual semver.org
      # compatible semantic version that looks something like this:
@ -89,13 +89,20 @@ kube::version::get_version_vars() {
      # Try to match the "git describe" output to a regex to try to extract
      # the "major" and "minor" versions and whether this is the exact tagged
      # version or whether the tree is between two tagged versions.
-      if [[ "${KUBE_GIT_VERSION}" =~ ^v([0-9]+)\.([0-9]+)(\.[0-9]+)?([-].*)?$ ]]; then
+      if [[ "${KUBE_GIT_VERSION}" =~ ^v([0-9]+)\.([0-9]+)(\.[0-9]+)?([-].*)?([+].*)?$ ]]; then
        KUBE_GIT_MAJOR=${BASH_REMATCH[1]}
        KUBE_GIT_MINOR=${BASH_REMATCH[2]}
        if [[ -n "${BASH_REMATCH[4]}" ]]; then
          KUBE_GIT_MINOR+="+"
        fi
      fi
+
+      # If KUBE_GIT_VERSION is not a valid Semantic Version, then refuse to build.
+      if ! [[ "${KUBE_GIT_VERSION}" =~ ^v([0-9]+)\.([0-9]+)(\.[0-9]+)?(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?$ ]]; then
+          echo "KUBE_GIT_VERSION should be a valid Semantic Version"
+          echo "Please see more details here: https://semver.org"
+          exit 1
+      fi
    fi
  fi
 }
@ -133,8 +140,8 @@ kube::version::ldflag() {
  local val=${2}

  # If you update these, also update the list pkg/version/def.bzl.
-  echo "-X ${KUBE_GO_PACKAGE}/pkg/version.${key}=${val}"
-  echo "-X ${KUBE_GO_PACKAGE}/vendor/k8s.io/client-go/pkg/version.${key}=${val}"
+  echo "-X '${KUBE_GO_PACKAGE}/pkg/version.${key}=${val}'"
+  echo "-X '${KUBE_GO_PACKAGE}/vendor/k8s.io/client-go/pkg/version.${key}=${val}'"
 }

 # Prints the value that needs to be passed to the -ldflags parameter of go build