Fresh dep ensure

2025-06-14 18:53:35 +00:00 · 2018-11-26 13:23:56 -05:00
parent 93cb8a04d7
commit 407478ab9a
9016 changed files with 551394 additions and 279685 deletions
--- a/vendor/k8s.io/kubernetes/hack/lib/etcd.sh
+++ b/vendor/k8s.io/kubernetes/hack/lib/etcd.sh
@ -16,14 +16,16 @@

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

-ETCD_VERSION=${ETCD_VERSION:-3.2.18}
+ETCD_VERSION=${ETCD_VERSION:-3.2.24}
 ETCD_HOST=${ETCD_HOST:-127.0.0.1}
 ETCD_PORT=${ETCD_PORT:-2379}
+export KUBE_INTEGRATION_ETCD_URL="http://${ETCD_HOST}:${ETCD_PORT}"

 kube::etcd::validate() {
  # validate if in path
  command -v etcd >/dev/null || {
    kube::log::usage "etcd must be in your PATH"
+    kube::log::info "You can use 'hack/install-etcd.sh' to install a copy in third_party/."
    exit 1
  }

@ -71,15 +73,15 @@ kube::etcd::start() {
  if [[ -d "${ARTIFACTS_DIR:-}" ]]; then
    ETCD_LOGFILE="${ARTIFACTS_DIR}/etcd.$(uname -n).$(id -un).log.DEBUG.$(date +%Y%m%d-%H%M%S).$$"
  else
-    ETCD_LOGFILE=/dev/null
+    ETCD_LOGFILE=${ETCD_LOGFILE:-"/dev/null"}
  fi
-  kube::log::info "etcd --advertise-client-urls http://${ETCD_HOST}:${ETCD_PORT} --data-dir ${ETCD_DIR} --listen-client-urls http://${ETCD_HOST}:${ETCD_PORT} --debug > \"${ETCD_LOGFILE}\" 2>/dev/null"
-  etcd --advertise-client-urls http://${ETCD_HOST}:${ETCD_PORT} --data-dir ${ETCD_DIR} --listen-client-urls http://${ETCD_HOST}:${ETCD_PORT} --debug 2> "${ETCD_LOGFILE}" >/dev/null &
+  kube::log::info "etcd --advertise-client-urls ${KUBE_INTEGRATION_ETCD_URL} --data-dir ${ETCD_DIR} --listen-client-urls http://${ETCD_HOST}:${ETCD_PORT} --debug > \"${ETCD_LOGFILE}\" 2>/dev/null"
+  etcd --advertise-client-urls ${KUBE_INTEGRATION_ETCD_URL} --data-dir ${ETCD_DIR} --listen-client-urls ${KUBE_INTEGRATION_ETCD_URL} --debug 2> "${ETCD_LOGFILE}" >/dev/null &
  ETCD_PID=$!

  echo "Waiting for etcd to come up."
-  kube::util::wait_for_url "http://${ETCD_HOST}:${ETCD_PORT}/v2/machines" "etcd: " 0.25 80
-  curl -fs -X PUT "http://${ETCD_HOST}:${ETCD_PORT}/v2/keys/_test"
+  kube::util::wait_for_url "${KUBE_INTEGRATION_ETCD_URL}/v2/machines" "etcd: " 0.25 80
+  curl -fs -X PUT "${KUBE_INTEGRATION_ETCD_URL}/v2/keys/_test"
 }

 kube::etcd::stop() {
@ -102,11 +104,13 @@ kube::etcd::cleanup() {

 kube::etcd::install() {
  (
+    local os
    cd "${KUBE_ROOT}/third_party"
-    if [[ $(readlink etcd) == etcd-v${ETCD_VERSION}-* ]]; then
+    os=$(uname | tr "[:upper:]" "[:lower:]")
+    if [[ $(readlink etcd) == etcd-v${ETCD_VERSION}-${os}-* ]]; then
      return  # already installed
    fi
-    if [[ $(uname) == "Darwin" ]]; then
+    if [[ ${os} == "darwin" ]]; then
      download_file="etcd-v${ETCD_VERSION}-darwin-amd64.zip"
      url="https://github.com/coreos/etcd/releases/download/v${ETCD_VERSION}/${download_file}"
      kube::util::download_file "${url}" "${download_file}"
@ -119,6 +123,7 @@ kube::etcd::install() {
      kube::util::download_file "${url}" "${download_file}"
      tar xzf "${download_file}"
      ln -fns "etcd-v${ETCD_VERSION}-linux-amd64" etcd
+      rm "${download_file}"
    fi
    kube::log::info "etcd v${ETCD_VERSION} installed. To use:"
    kube::log::info "export PATH=$(pwd)/etcd:\${PATH}"
--- a/vendor/k8s.io/kubernetes/hack/lib/golang.sh
+++ b/vendor/k8s.io/kubernetes/hack/lib/golang.sh
@ -30,7 +30,6 @@ kube::golang::server_targets() {
    cmd/kubeadm
    cmd/hyperkube
    cmd/kube-scheduler
-    vendor/k8s.io/kube-aggregator
    vendor/k8s.io/apiextensions-apiserver
    cluster/gce/gci/mounter
  )
@ -41,6 +40,37 @@ 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 we build docker images for
+kube::golang::server_image_targets() {
+  # NOTE: this contains cmd targets for kube::build::get_docker_wrapped_binaries
+  local targets=(
+    cmd/cloud-controller-manager
+    cmd/kube-apiserver
+    cmd/kube-controller-manager
+    cmd/kube-scheduler
+    cmd/kube-proxy
+  )
+  echo "${targets[@]}"
+}
+
+IFS=" " read -ra KUBE_SERVER_IMAGE_TARGETS <<< "$(kube::golang::server_image_targets)"
+readonly KUBE_SERVER_IMAGE_TARGETS
+readonly KUBE_SERVER_IMAGE_BINARIES=("${KUBE_SERVER_IMAGE_TARGETS[@]##*/}")
+
+# The set of conformance targets we build docker image for
+kube::golang::conformance_image_targets() {
+  # NOTE: this contains cmd targets for kube::release::build_conformance_image
+  local targets=(
+    vendor/github.com/onsi/ginkgo/ginkgo
+    test/e2e/e2e.test
+    cmd/kubectl
+  )
+  echo "${targets[@]}"
+}
+
+IFS=" " read -ra KUBE_CONFORMANCE_IMAGE_TARGETS <<< "$(kube::golang::conformance_image_targets)"
+readonly KUBE_CONFORMANCE_IMAGE_TARGETS
+
 # The set of server targets that we are only building for Kubernetes nodes
 # If you update this list, please also update build/BUILD.
 kube::golang::node_targets() {
@ -208,11 +238,19 @@ readonly KUBE_STATIC_LIBRARIES=(
  kube-controller-manager
  kube-scheduler
  kube-proxy
-  kube-aggregator
  kubeadm
  kubectl
 )

+# Fully-qualified package names that we want to instrument for coverage information.
+readonly KUBE_COVERAGE_INSTRUMENTED_PACKAGES=(
+  k8s.io/kubernetes/cmd/kube-apiserver
+  k8s.io/kubernetes/cmd/kube-controller-manager
+  k8s.io/kubernetes/cmd/kube-scheduler
+  k8s.io/kubernetes/cmd/kube-proxy
+  k8s.io/kubernetes/cmd/kubelet
+)
+
 # KUBE_CGO_OVERRIDES is a space-separated list of binaries which should be built
 # with CGO enabled, assuming CGO is supported on the target platform.
 # This overrides any entry in KUBE_STATIC_LIBRARIES.
@ -336,7 +374,7 @@ EOF
  local go_version
  IFS=" " read -ra go_version <<< "$(go version)"
  local minimum_go_version
-  minimum_go_version=go1.10.2
+  minimum_go_version=go1.11.1
  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[*]}.
@ -443,6 +481,100 @@ kube::golang::outfile_for_binary() {
  echo "${output_path}/${bin}"
 }

+# Argument: the name of a Kubernetes package.
+# Returns 0 if the binary can be built with coverage, 1 otherwise.
+# NB: this ignores whether coverage is globally enabled or not.
+kube::golang::is_instrumented_package() {
+  return $(kube::util::array_contains "$1" "${KUBE_COVERAGE_INSTRUMENTED_PACKAGES[@]}")
+}
+
+# Argument: the name of a Kubernetes package (e.g. k8s.io/kubernetes/cmd/kube-scheduler)
+# Echos the path to a dummy test used for coverage information.
+kube::golang::path_for_coverage_dummy_test() {
+  local package="$1"
+  local path="${KUBE_GOPATH}/src/${package}"
+  local name=$(basename "${package}")
+  echo "$path/zz_generated_${name}_test.go"
+}
+
+# Argument: the name of a Kubernetes package (e.g. k8s.io/kubernetes/cmd/kube-scheduler).
+# Creates a dummy unit test on disk in the source directory for the given package.
+# This unit test will invoke the package's standard entry point when run.
+kube::golang::create_coverage_dummy_test() {
+  local package="$1"
+  local name="$(basename "${package}")"
+  cat <<EOF > $(kube::golang::path_for_coverage_dummy_test "${package}")
+package main
+import (
+  "testing"
+  "k8s.io/kubernetes/pkg/util/coverage"
+)
+
+func TestMain(m *testing.M) {
+  // Get coverage running
+  coverage.InitCoverage("${name}")
+
+  // Go!
+  main()
+
+  // Make sure we actually write the profiling information to disk, if we make it here.
+  // On long-running services, or anything that calls os.Exit(), this is insufficient,
+  // so we also flush periodically with a default period of five seconds (configurable by
+  // the KUBE_COVERAGE_FLUSH_INTERVAL environment variable).
+  coverage.FlushCoverage()
+}
+EOF
+}
+
+# Argument: the name of a Kubernetes package (e.g. k8s.io/kubernetes/cmd/kube-scheduler).
+# Deletes a test generated by kube::golang::create_coverage_dummy_test.
+# It is not an error to call this for a nonexistent test.
+kube::golang::delete_coverage_dummy_test() {
+  local package="$1"
+  rm -f $(kube::golang::path_for_coverage_dummy_test "${package}")
+}
+
+# Arguments: a list of kubernetes packages to build.
+# Expected variables: ${build_args} should be set to an array of Go build arguments.
+# In addition, ${package} and ${platform} should have been set earlier, and if
+# ${KUBE_BUILD_WITH_COVERAGE} is set, coverage instrumentation will be enabled.
+#
+# Invokes Go to actually build some packages. If coverage is disabled, simply invokes
+# go install. If coverage is enabled, builds covered binaries using go test, temporarily
+# producing the required unit test files and then cleaning up after itself.
+# Non-covered binaries are then built using go install as usual.
+kube::golang::build_some_binaries() {
+  if [[ -n "${KUBE_BUILD_WITH_COVERAGE:-}" ]]; then
+    local -a uncovered=()
+    for package in "$@"; do
+      if kube::golang::is_instrumented_package "${package}"; then
+        V=2 kube::log::info "Building ${package} with coverage..."
+
+        kube::golang::create_coverage_dummy_test "${package}"
+        kube::util::trap_add "kube::golang::delete_coverage_dummy_test \"${package}\"" EXIT
+
+        go test -c -o "$(kube::golang::outfile_for_binary "${package}" "${platform}")" \
+          -covermode count \
+          -coverpkg k8s.io/...,k8s.io/kubernetes/vendor/k8s.io/... \
+          "${build_args[@]}" \
+          -tags coverage \
+          "${package}"
+      else
+        uncovered+=("${package}")
+      fi
+    done
+    if [[ "${#uncovered[@]}" != 0 ]]; then
+      V=2 kube::log::info "Building ${uncovered[@]} without coverage..."
+      go install "${build_args[@]}" "${uncovered[@]}"
+    else
+      V=2 kube::log::info "Nothing to build without coverage."
+     fi
+   else
+    V=2 kube::log::info "Coverage is disabled."
+    go install "${build_args[@]}" "$@"
+   fi
+}
+
 kube::golang::build_binaries_for_platform() {
  local platform=$1

@ -462,18 +594,26 @@ kube::golang::build_binaries_for_platform() {
    fi
  done

+  local -a build_args
  if [[ "${#statics[@]}" != 0 ]]; then
-    CGO_ENABLED=0 go install -installsuffix static "${goflags[@]:+${goflags[@]}}" \
-      -gcflags "${gogcflags}" \
-      -ldflags "${goldflags}" \
-      "${statics[@]:+${statics[@]}}"
+    build_args=(
+      -installsuffix static
+      ${goflags:+"${goflags[@]}"}
+      -gcflags "${gogcflags:-}"
+      -asmflags "${goasmflags:-}"
+      -ldflags "${goldflags:-}"
+    )
+    CGO_ENABLED=0 kube::golang::build_some_binaries "${statics[@]}"
  fi

  if [[ "${#nonstatics[@]}" != 0 ]]; then
-    go install "${goflags[@]:+${goflags[@]}}" \
-      -gcflags "${gogcflags}" \
-      -ldflags "${goldflags}" \
-      "${nonstatics[@]:+${nonstatics[@]}}"
+    build_args=(
+      ${goflags:+"${goflags[@]}"}
+      -gcflags "${gogcflags:-}"
+      -asmflags "${goasmflags:-}"
+      -ldflags "${goldflags:-}"
+    )
+    kube::golang::build_some_binaries "${nonstatics[@]}"
  fi

  for test in "${tests[@]:+${tests[@]}}"; do
@ -482,9 +622,10 @@ kube::golang::build_binaries_for_platform() {

    mkdir -p "$(dirname ${outfile})"
    go test -c \
-      "${goflags[@]:+${goflags[@]}}" \
-      -gcflags "${gogcflags}" \
-      -ldflags "${goldflags}" \
+      ${goflags:+"${goflags[@]}"} \
+      -gcflags "${gogcflags:-}" \
+      -asmflags "${goasmflags:-}" \
+      -ldflags "${goldflags:-}" \
      -o "${outfile}" \
      "${testpkg}"
  done
@ -537,10 +678,11 @@ kube::golang::build_binaries() {
    host_platform=$(kube::golang::host_platform)

    # Use eval to preserve embedded quoted strings.
-    local goflags goldflags gogcflags
+    local goflags goldflags goasmflags gogcflags
    eval "goflags=(${GOFLAGS:-})"
-    goldflags="${GOLDFLAGS:-} $(kube::version::ldflags)"
-    gogcflags="${GOGCFLAGS:-}"
+    goldflags="${GOLDFLAGS:-} -s -w $(kube::version::ldflags)"
+    goasmflags="-trimpath=${KUBE_ROOT}"
+    gogcflags="${GOGCFLAGS:-} -trimpath=${KUBE_ROOT}"

    local -a targets=()
    local arg
--- a/vendor/k8s.io/kubernetes/hack/lib/init.sh
+++ b/vendor/k8s.io/kubernetes/hack/lib/init.sh
@ -62,16 +62,19 @@ admission.k8s.io/v1beta1 \
 apps/v1beta1 \
 apps/v1beta2 \
 apps/v1 \
+auditregistration.k8s.io/v1alpha1 \
 authentication.k8s.io/v1 \
 authentication.k8s.io/v1beta1 \
 authorization.k8s.io/v1 \
 authorization.k8s.io/v1beta1 \
 autoscaling/v1 \
 autoscaling/v2beta1 \
+autoscaling/v2beta2 \
 batch/v1 \
 batch/v1beta1 \
 batch/v2alpha1 \
 certificates.k8s.io/v1beta1 \
+coordination.k8s.io/v1beta1 \
 extensions/v1beta1 \
 events.k8s.io/v1beta1 \
 imagepolicy.k8s.io/v1alpha1 \
@ -178,4 +181,3 @@ kube::realpath() {
  fi
  kube::readlinkdashf "$1"
 }
-
--- a/vendor/k8s.io/kubernetes/hack/lib/util.sh
+++ b/vendor/k8s.io/kubernetes/hack/lib/util.sh
@ -18,6 +18,20 @@ kube::util::sortable_date() {
  date "+%Y%m%d-%H%M%S"
 }

+# arguments: target, item1, item2, item3, ...
+# returns 0 if target is in the given items, 1 otherwise.
+kube::util::array_contains() {
+  local search="$1"
+  local element
+  shift
+  for element; do
+    if [[ "${element}" == "${search}" ]]; then
+      return 0
+     fi
+  done
+  return 1
+}
+
 kube::util::wait_for_url() {
  local url=$1
  local prefix=${2:-}
@ -149,11 +163,11 @@ kube::util::find-binary-for-platform() {
    "${KUBE_ROOT}/platforms/${platform}/${lookfor}"
  )
  # Also search for binary in bazel build tree.
-  # The bazel go rules place binaries in subtrees like
+  # The bazel go rules place some 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 \
-    -path "*/${platform/\//_}*/${lookfor}" 2>/dev/null || true) )
+    \( -path "*/${platform/\//_}*/${lookfor}" -o -path "*/${lookfor}" \) 2>/dev/null || true) )

  # List most recently-updated location.
  local -r bin=$( (ls -t "${locations[@]}" 2>/dev/null || true) | head -1 )
@ -308,7 +322,7 @@ kube::util::gv-to-swagger-name() {
 # Assumed vars:
 # SWAGGER_API_PATH: Base path for swaggerapi on apiserver. Ex:
 # http://localhost:8080/swaggerapi.
-# SWAGGER_ROOT_DIR: Root dir where we want to to save the fetched spec.
+# SWAGGER_ROOT_DIR: Root dir where we want to save the fetched spec.
 # VERSIONS: Array of group versions to include in swagger spec.
 kube::util::fetch-swagger-spec() {
  for ver in ${VERSIONS}; do
@ -427,28 +441,30 @@ kube::util::ensure_clean_working_dir() {

 # Ensure that the given godep version is installed and in the path.  Almost
 # nobody should use any version but the default.
+#
+# Sets:
+#  KUBE_GODEP: The path to the godep binary
+#
 kube::util::ensure_godep_version() {
-  GODEP_VERSION=${1:-"v80"} # this version is known to work
+  local godep_target_version=${1:-"v80-k8s-r1"} # this version is known to work

-  if [[ "$(godep version 2>/dev/null)" == *"godep ${GODEP_VERSION}"* ]]; then
+  # If KUBE_GODEP is already set, and it's the right version, then use it.
+  if [[ -n "${KUBE_GODEP:-}" && "$(${KUBE_GODEP:?} version 2>/dev/null)" == *"godep ${godep_target_version}"* ]]; then
+    kube::log::status "Using ${KUBE_GODEP}"
    return
  fi

-  kube::log::status "Installing godep version ${GODEP_VERSION}"
-  go install ./vendor/github.com/tools/godep/
-  if ! which godep >/dev/null 2>&1; then
-    kube::log::error "Can't find godep - is your GOPATH 'bin' in your PATH?"
-    kube::log::error "  GOPATH: ${GOPATH}"
-    kube::log::error "  PATH:   ${PATH}"
-    return 1
-  fi
+  # Otherwise, install forked godep
+  kube::log::status "Installing godep version ${godep_target_version}"
+  # Run in hermetic GOPATH
+  kube::golang::setup_env
+  go install k8s.io/kubernetes/third_party/forked/godep
+  export KUBE_GODEP="${KUBE_GOPATH}/bin/godep"
+  kube::log::status "Installed ${KUBE_GODEP}"

-  if [[ "$(godep version 2>/dev/null)" != *"godep ${GODEP_VERSION}"* ]]; then
-    kube::log::error "Wrong godep version - is your GOPATH 'bin' in your PATH?"
-    kube::log::error "  expected: godep ${GODEP_VERSION}"
-    kube::log::error "  got:      $(godep version)"
-    kube::log::error "  GOPATH: ${GOPATH}"
-    kube::log::error "  PATH:   ${PATH}"
+  # Verify that the installed godep from fork is what we expect
+  if [[ "$(${KUBE_GODEP:?} version 2>/dev/null)" != *"godep ${godep_target_version}"* ]]; then
+    kube::log::error "Expected godep ${godep_target_version} from ${KUBE_GODEP}, got $(${KUBE_GODEP:?} version)"
    return 1
  fi
 }
@ -540,6 +556,7 @@ function kube::util::test_openssl_installed {
      echo "Failed to run openssl. Please ensure openssl is installed"
      exit 1
    fi
+
    OPENSSL_BIN=$(command -v openssl)
 }

@ -787,6 +804,8 @@ if [[ -z "${color_start-}" ]]; then
  declare -r color_red="${color_start}0;31m"
  declare -r color_yellow="${color_start}0;33m"
  declare -r color_green="${color_start}0;32m"
+  declare -r color_blue="${color_start}1;34m"
+  declare -r color_cyan="${color_start}1;36m"
  declare -r color_norm="${color_start}0m"
 fi