Switch to github.com/golang/dep for vendoring

Signed-off-by: Mrunal Patel <mrunalp@gmail.com>
2017-01-31 16:45:59 -08:00 · 2017-01-31 16:45:59 -08:00 · 8e5b17cf13
commit 8e5b17cf13
parent d6ab91be27
15431 changed files with 3971413 additions and 8881 deletions
--- a/vendor/k8s.io/kubernetes/hack/make-rules/build.sh
+++ b/vendor/k8s.io/kubernetes/hack/make-rules/build.sh
@ -0,0 +1,28 @@
+#!/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.
+
+# This script sets up a go workspace locally and builds all go components.
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+KUBE_ROOT=$(dirname "${BASH_SOURCE}")/../..
+KUBE_VERBOSE="${KUBE_VERBOSE:-1}"
+source "${KUBE_ROOT}/hack/lib/init.sh"
+
+kube::golang::build_binaries "$@"
+kube::golang::place_bins
--- a/vendor/k8s.io/kubernetes/hack/make-rules/cross.sh
+++ b/vendor/k8s.io/kubernetes/hack/make-rules/cross.sh
@ -0,0 +1,38 @@
+#!/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.
+
+# This script sets up a go workspace locally and builds all for all appropriate
+# platforms.
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+KUBE_ROOT=$(dirname "${BASH_SOURCE}")/../..
+source "${KUBE_ROOT}/hack/lib/init.sh"
+
+# NOTE: Using "${array[*]}" here is correct.  [@] becomes distinct words (in
+# bash parlance).
+
+make all WHAT="${KUBE_SERVER_TARGETS[*]}" KUBE_BUILD_PLATFORMS="${KUBE_SERVER_PLATFORMS[*]}"
+
+make all WHAT="${KUBE_NODE_TARGETS[*]}" KUBE_BUILD_PLATFORMS="${KUBE_NODE_PLATFORMS[*]}"
+
+make all WHAT="${KUBE_CLIENT_TARGETS[*]}" KUBE_BUILD_PLATFORMS="${KUBE_CLIENT_PLATFORMS[*]}"
+
+make all WHAT="${KUBE_TEST_TARGETS[*]}" KUBE_BUILD_PLATFORMS="${KUBE_TEST_PLATFORMS[*]}"
+
+make all WHAT="${KUBE_TEST_SERVER_TARGETS[*]}" KUBE_BUILD_PLATFORMS="${KUBE_TEST_SERVER_PLATFORMS[*]}"
--- a/vendor/k8s.io/kubernetes/hack/make-rules/helpers/cache_go_dirs.sh
+++ b/vendor/k8s.io/kubernetes/hack/make-rules/helpers/cache_go_dirs.sh
@ -0,0 +1,73 @@
+#!/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.
+
+# This script finds, caches, and prints a list of all directories that hold
+# *.go files.  If any directory is newer than the cache, re-find everything and
+# update the cache.  Otherwise use the cached file.
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+if [[ -z "${1:-}" ]]; then
+    echo "usage: $0 <cache-file>"
+    exit 1
+fi
+CACHE="$1"; shift
+
+trap "rm -f '${CACHE}'" HUP INT TERM ERR
+
+# This is a partial 'find' command.  The caller is expected to pass the
+# remaining arguments.
+#
+# Example:
+#   kfind -type f -name foobar.go
+function kfind() {
+    # include the "special" vendor directories which are actually part
+    # of the Kubernetes source tree - generators will use these for
+    # including certain core API concepts.
+    find -H . ./vendor/k8s.io/apimachinery ./vendor/k8s.io/apiserver \
+        \(                         \
+        -not \(                    \
+            \(                     \
+                -path ./vendor -o  \
+                -path ./staging -o \
+                -path ./_\* -o     \
+                -path ./.\* -o     \
+                -path ./docs -o    \
+                -path ./examples   \
+            \) -prune              \
+        \)                         \
+        \)                         \
+        "$@"
+}
+
+NEED_FIND=true
+# It's *significantly* faster to check whether any directories are newer than
+# the cache than to blindly rebuild it.
+if [[ -f "${CACHE}" ]]; then
+    N=$(kfind -type d -newer "${CACHE}" -print -quit | wc -l)
+    [[ "${N}" == 0 ]] && NEED_FIND=false
+fi
+mkdir -p $(dirname "${CACHE}")
+if $("${NEED_FIND}"); then
+    kfind -type f -name \*.go  \
+        | sed 's|/[^/]*$||'    \
+        | sed 's|^./||'        \
+        | LC_ALL=C sort -u     \
+        > "${CACHE}"
+fi
+cat "${CACHE}"
--- a/vendor/k8s.io/kubernetes/hack/make-rules/make-help.sh
+++ b/vendor/k8s.io/kubernetes/hack/make-rules/make-help.sh
@ -0,0 +1,83 @@
+#!/bin/bash
+
+# Copyright 2016 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.
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+red='\E[1;31m'
+reset='\E[0m'
+
+KUBE_ROOT=$(dirname "${BASH_SOURCE}")/../..
+ALL_TARGETS=$(make -C "${KUBE_ROOT}" PRINT_HELP=y -rpn | sed -n -e '/^$/ { n ; /^[^ .#][^ ]*:/ { s/:.*$// ; p ; } ; }' | sort)
+CMD_TARGETS=$(ls -l "${KUBE_ROOT}/cmd" |awk '/^d/ {print $NF}')
+PLUGIN_CMD_TARGETS=$(ls -l "${KUBE_ROOT}/plugin/cmd" |awk '/^d/ {print $NF}')
+FED_CMD_TARGETS=$(ls -l "${KUBE_ROOT}/federation/cmd" |awk '/^d/ {print $NF}')
+CMD_FLAG=false
+PLUGIN_CMD_FLAG=false
+FED_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
+				continue 2;
+			fi
+
+			echo -e "${red}${CMD_TARGETS}${reset}"
+			make -C "${KUBE_ROOT}" $tar PRINT_HELP=y
+			echo "---------------------------------------------------------------------------------"
+
+			CMD_FLAG=true
+			continue 2
+		fi
+	done
+
+	for plugincmdtar in $PLUGIN_CMD_TARGETS; do
+		if [ $tar = $plugincmdtar ]; then
+			if [ $PLUGIN_CMD_FLAG = true ]; then
+				continue 2;
+			fi
+
+			echo -e "${red}${PLUGIN_CMD_TARGETS}${reset}"
+			make -C "${KUBE_ROOT}" $tar PRINT_HELP=y
+			echo "---------------------------------------------------------------------------------"
+
+			PLUGIN_CMD_FLAG=true
+			continue 2
+		fi
+	done
+
+	for fedcmdtar in $FED_CMD_TARGETS; do
+		if [ $tar = $fedcmdtar ]; then
+			if [ $FED_CMD_FLAG = true ]; then
+				continue 2;
+			fi
+
+			echo -e "${red}${FED_CMD_TARGETS}${reset}"
+			make -C "${KUBE_ROOT}" $tar PRINT_HELP=y
+			echo "---------------------------------------------------------------------------------"
+
+			FED_CMD_FLAG=true
+			continue 2
+		fi
+	done
+
+	echo -e "${red}${tar}${reset}"
+	make -C "${KUBE_ROOT}" $tar PRINT_HELP=y
+	echo "---------------------------------------------------------------------------------"
+done
--- a/vendor/k8s.io/kubernetes/hack/make-rules/test-cmd-util.sh
+++ b/vendor/k8s.io/kubernetes/hack/make-rules/test-cmd-util.sh
--- a/vendor/k8s.io/kubernetes/hack/make-rules/test-cmd.sh
+++ b/vendor/k8s.io/kubernetes/hack/make-rules/test-cmd.sh
@ -0,0 +1,144 @@
+#!/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.
+
+# This command checks that the built commands can function together for
+# simple scenarios.  It does not require Docker.
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+KUBE_ROOT=$(dirname "${BASH_SOURCE}")/../..
+source "${KUBE_ROOT}/hack/make-rules/test-cmd-util.sh"
+
+function run_kube_apiserver() {
+  kube::log::status "Building kube-apiserver"
+  make -C "${KUBE_ROOT}" WHAT="cmd/kube-apiserver"
+
+  # Start kube-apiserver
+  kube::log::status "Starting kube-apiserver"
+
+  # Admission Controllers to invoke prior to persisting objects in cluster
+  ADMISSION_CONTROL="NamespaceLifecycle,LimitRanger,ResourceQuota"
+
+  "${KUBE_OUTPUT_HOSTBIN}/kube-apiserver" \
+    --address="127.0.0.1" \
+    --public-address-override="127.0.0.1" \
+    --port="${API_PORT}" \
+    --admission-control="${ADMISSION_CONTROL}" \
+    --etcd-servers="http://${ETCD_HOST}:${ETCD_PORT}" \
+    --public-address-override="127.0.0.1" \
+    --kubelet-port=${KUBELET_PORT} \
+    --runtime-config=api/v1 \
+    --storage-media-type="${KUBE_TEST_API_STORAGE_TYPE-}" \
+    --cert-dir="${TMPDIR:-/tmp/}" \
+    --service-cluster-ip-range="10.0.0.0/24" 1>&2 &
+  APISERVER_PID=$!
+
+  kube::util::wait_for_url "http://127.0.0.1:${API_PORT}/healthz" "apiserver"
+}
+
+function run_kube_controller_manager() {
+  kube::log::status "Building kube-controller-manager"
+  make -C "${KUBE_ROOT}" WHAT="cmd/kube-controller-manager"
+
+  # Start controller manager
+  kube::log::status "Starting controller-manager"
+  "${KUBE_OUTPUT_HOSTBIN}/kube-controller-manager" \
+    --port="${CTLRMGR_PORT}" \
+    --kube-api-content-type="${KUBE_TEST_API_TYPE-}" \
+    --master="127.0.0.1:${API_PORT}" 1>&2 &
+  CTLRMGR_PID=$!
+
+  kube::util::wait_for_url "http://127.0.0.1:${CTLRMGR_PORT}/healthz" "controller-manager"
+}
+
+function run_kubelet() {
+  # Only run kubelet on platforms it supports
+  if [[ "$(go env GOHOSTOS)" == "linux" ]]; then
+    kube::log::status "Building kubelet"
+    make -C "${KUBE_ROOT}" WHAT="cmd/kubelet"
+
+    kube::log::status "Starting kubelet in masterless mode"
+    "${KUBE_OUTPUT_HOSTBIN}/kubelet" \
+      --really-crash-for-testing=true \
+      --root-dir=/tmp/kubelet.$$ \
+      --cert-dir="${TMPDIR:-/tmp/}" \
+      --docker-endpoint="fake://" \
+      --hostname-override="127.0.0.1" \
+      --address="127.0.0.1" \
+      --port="$KUBELET_PORT" \
+      --healthz-port="${KUBELET_HEALTHZ_PORT}" 1>&2 &
+    KUBELET_PID=$!
+    kube::util::wait_for_url "http://127.0.0.1:${KUBELET_HEALTHZ_PORT}/healthz" "kubelet(masterless)"
+    kill ${KUBELET_PID} 1>&2 2>/dev/null
+
+    kube::log::status "Starting kubelet in masterful mode"
+    "${KUBE_OUTPUT_HOSTBIN}/kubelet" \
+      --really-crash-for-testing=true \
+      --root-dir=/tmp/kubelet.$$ \
+      --cert-dir="${TMPDIR:-/tmp/}" \
+      --docker-endpoint="fake://" \
+      --hostname-override="127.0.0.1" \
+      --address="127.0.0.1" \
+      --api-servers="${API_HOST}:${API_PORT}" \
+      --port="$KUBELET_PORT" \
+      --healthz-port="${KUBELET_HEALTHZ_PORT}" 1>&2 &
+    KUBELET_PID=$!
+
+    kube::util::wait_for_url "http://127.0.0.1:${KUBELET_HEALTHZ_PORT}/healthz" "kubelet"
+  fi
+}
+
+# Creates a node object with name 127.0.0.1 if it doesnt exist already.
+# This is required for non-linux platforms where we do not run kubelet.
+function create_node() {
+  if [[ "$(go env GOHOSTOS)" == "linux" ]]; then
+    kube::util::wait_for_url "http://127.0.0.1:${API_PORT}/api/v1/nodes/127.0.0.1" "apiserver(nodes)"
+  else
+    # create a fake node
+    kubectl create -f - -s "http://127.0.0.1:${API_PORT}" << __EOF__
+{
+  "kind": "Node",
+  "apiVersion": "v1",
+  "metadata": {
+    "name": "127.0.0.1"
+  },
+  "status": {
+    "capacity": {
+      "memory": "1Gi"
+    }
+  }
+}
+__EOF__
+  fi
+}
+
+kube::log::status "Running kubectl tests for kube-apiserver"
+
+setup
+run_kube_apiserver
+run_kube_controller_manager
+run_kubelet
+create_node
+SUPPORTED_RESOURCES=("*")
+output_message=$(runTests "SUPPORTED_RESOURCES=${SUPPORTED_RESOURCES[@]}")
+# Ensure that tests were run. We cannot check all resources here. We check a few
+# to catch bugs due to which no tests run.
+kube::test::if_has_string "${output_message}" "Testing kubectl(v1:pods)"
+kube::test::if_has_string "${output_message}" "Testing kubectl(v1:services)"
+
+kube::log::status "TESTS PASSED"
--- a/vendor/k8s.io/kubernetes/hack/make-rules/test-e2e-node.sh
+++ b/vendor/k8s.io/kubernetes/hack/make-rules/test-e2e-node.sh
@ -0,0 +1,153 @@
+#!/bin/bash
+
+# Copyright 2016 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.
+
+KUBE_ROOT=$(dirname "${BASH_SOURCE}")/../..
+source "${KUBE_ROOT}/hack/lib/init.sh"
+
+focus=${FOCUS:-""}
+skip=${SKIP-"\[Flaky\]|\[Slow\]|\[Serial\]"}
+# The number of tests that can run in parallel depends on what tests
+# are running and on the size of the node. Too many, and tests will
+# fail due to resource contention. 8 is a reasonable default for a
+# n1-standard-1 node.
+# Currently, parallelism only affects when REMOTE=true. For local test,
+# ginkgo default parallelism (cores - 1) is used.
+parallelism=${PARALLELISM:-8}
+artifacts=${ARTIFACTS:-"/tmp/_artifacts/`date +%y%m%dT%H%M%S`"}
+remote=${REMOTE:-"false"}
+run_until_failure=${RUN_UNTIL_FAILURE:-"false"}
+test_args=${TEST_ARGS:-""}
+
+# Parse the flags to pass to ginkgo
+ginkgoflags=""
+if [[ $parallelism > 1 ]]; then
+  ginkgoflags="$ginkgoflags -nodes=$parallelism "
+fi
+
+if [[ $focus != "" ]]; then
+  ginkgoflags="$ginkgoflags -focus=\"$focus\" "
+fi
+
+if [[ $skip != "" ]]; then
+  ginkgoflags="$ginkgoflags -skip=\"$skip\" "
+fi
+
+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
+if [ ! -d "${artifacts}" ]; then
+  echo "Creating artifacts directory at ${artifacts}"
+  mkdir -p ${artifacts}
+fi
+echo "Test artifacts will be written to ${artifacts}"
+
+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
+    gcloud compute images list --project="${image_project}" | grep "e2e-node"
+    exit 0
+  fi
+  gubernator=${GUBERNATOR:-"false"}
+  if [[ $hosts == "" && $images == "" ]]; then
+    image_project=${IMAGE_PROJECT:-"google-containers"}
+    gci_image=$(gcloud compute images list --project $image_project \
+    --no-standard-images --regexp="gci-dev.*" --format="table[no-heading](name)")
+    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"}
+  cleanup=${CLEANUP:-"true"}
+  delete_instances=${DELETE_INSTANCES:-"false"}
+
+  # Get the compute zone
+  zone=$(gcloud info --format='value(config.properties.compute.zone)')
+  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
+    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"
+       images=""
+       for i in "${IM[@]}"; do
+         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,"
+           fi
+           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"
+  # 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" \
+    2>&1 | tee -i "${artifacts}/build-log.txt"
+  exit $?
+
+else
+  # Refresh sudo credentials for local run
+  if ! ping -c 1 -q metadata.google.internal &> /dev/null; then
+    echo "Updating sudo credentials"
+    sudo -v || exit 1
+  fi
+
+  # Do not use any network plugin by default. User could override the flags with
+  # test_args.
+  test_args='--kubelet-flags="--network-plugin= --network-plugin-dir=" '$test_args
+
+  # Test using the host the script was run on
+  # Provided for backwards compatibility
+  go run test/e2e_node/runner/local/run_local.go --ginkgo-flags="$ginkgoflags" \
+    --test-flags="--alsologtostderr --v 4 --report-dir=${artifacts} --node-name $(hostname) \
+    $test_args" --build-dependencies=true 2>&1 | tee -i "${artifacts}/build-log.txt"
+  exit $?
+fi
--- a/vendor/k8s.io/kubernetes/hack/make-rules/test-federation-cmd.sh
+++ b/vendor/k8s.io/kubernetes/hack/make-rules/test-federation-cmd.sh
@ -0,0 +1,84 @@
+#!/bin/bash
+
+# Copyright 2016 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.
+
+# This command checks that the built commands can function together for
+# simple scenarios.  It does not require Docker.
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+KUBE_ROOT=$(dirname "${BASH_SOURCE}")/../..
+source "${KUBE_ROOT}/hack/make-rules/test-cmd-util.sh"
+
+function run_federation_apiserver() {
+  kube::log::status "Building federation-apiserver"
+  make -C "${KUBE_ROOT}" WHAT="federation/cmd/federation-apiserver"
+
+  # Start federation-apiserver
+  kube::log::status "Starting federation-apiserver"
+
+  # Admission Controllers to invoke prior to persisting objects in cluster
+  ADMISSION_CONTROL="NamespaceLifecycle"
+
+  "${KUBE_OUTPUT_HOSTBIN}/federation-apiserver" \
+    --insecure-port="${API_PORT}" \
+    --admission-control="${ADMISSION_CONTROL}" \
+    --etcd-servers="http://${ETCD_HOST}:${ETCD_PORT}" \
+    --storage-media-type="${KUBE_TEST_API_STORAGE_TYPE-}" \
+    --cert-dir="${TMPDIR:-/tmp/}" 1>&2 &
+  APISERVER_PID=$!
+
+  kube::util::wait_for_url "http://127.0.0.1:${API_PORT}/healthz" "apiserver"
+}
+
+function run_federation_controller_manager() {
+  kube::log::status "Building federation-controller-manager"
+  make -C "${KUBE_ROOT}" WHAT="federation/cmd/federation-controller-manager"
+
+  # Create a kubeconfig for federation apiserver.
+  local kubeconfig="${KUBE_TEMP}/kubeconfig"
+  touch "${kubeconfig}"
+  kubectl config set-cluster "apiserver" --server="http://127.0.0.1:${API_PORT}" --insecure-skip-tls-verify=true --kubeconfig="${kubeconfig}"
+  kubectl config set-context "context" --cluster="apiserver" --kubeconfig="${kubeconfig}"
+  kubectl config use-context "context" --kubeconfig="${kubeconfig}"
+
+  # Start controller manager
+  kube::log::status "Starting federation-controller-manager"
+  "${KUBE_OUTPUT_HOSTBIN}/federation-controller-manager" \
+    --port="${CTLRMGR_PORT}" \
+    --kubeconfig="${kubeconfig}" \
+    --kube-api-content-type="${KUBE_TEST_API_TYPE-}" \
+    --master="127.0.0.1:${API_PORT}" 1>&2 &
+  CTLRMGR_PID=$!
+
+  kube::util::wait_for_url "http://127.0.0.1:${CTLRMGR_PORT}/healthz" "controller-manager"
+}
+
+kube::log::status "Running kubectl tests for federation-apiserver"
+
+setup
+run_federation_apiserver
+run_federation_controller_manager
+# TODO: Fix for replicasets and deployments.
+SUPPORTED_RESOURCES=("configmaps" "daemonsets" "events" "ingress" "namespaces" "secrets" "services")
+output_message=$(runTests "SUPPORTED_RESOURCES=${SUPPORTED_RESOURCES[@]}")
+# Ensure that tests were run. We cannot check all resources here. We check a few
+# to catch bugs due to which no tests run.
+kube::test::if_has_string "${output_message}" "Testing kubectl(v1:namespaces)"
+kube::test::if_has_string "${output_message}" "Testing kubectl(v1:services)"
+
+kube::log::status "TESTS PASSED"
--- a/vendor/k8s.io/kubernetes/hack/make-rules/test-integration.sh
+++ b/vendor/k8s.io/kubernetes/hack/make-rules/test-integration.sh
@ -0,0 +1,108 @@
+#!/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.
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+KUBE_ROOT=$(dirname "${BASH_SOURCE}")/../..
+source "${KUBE_ROOT}/hack/lib/init.sh"
+# Lists of API Versions of each groups that should be tested, groups are
+# separated by comma, lists are separated by semicolon. e.g.,
+# "v1,compute/v1alpha1,experimental/v1alpha2;v1,compute/v2,experimental/v1alpha3"
+# TODO: It's going to be:
+# KUBE_TEST_API_VERSIONS=${KUBE_TEST_API_VERSIONS:-"v1,extensions/v1beta1"}
+# FIXME: due to current implementation of a test client (see: pkg/api/testapi/testapi.go)
+# ONLY the last version is tested in each group.
+ALL_VERSIONS_CSV=$(IFS=',';echo "${KUBE_AVAILABLE_GROUP_VERSIONS[*]// /,}";IFS=$)
+KUBE_TEST_API_VERSIONS="${KUBE_TEST_API_VERSIONS:-${ALL_VERSIONS_CSV}}"
+
+# Give integration tests longer to run
+# TODO: allow a larger value to be passed in
+#KUBE_TIMEOUT=${KUBE_TIMEOUT:--timeout 240s}
+KUBE_TIMEOUT="-timeout 600s"
+KUBE_INTEGRATION_TEST_MAX_CONCURRENCY=${KUBE_INTEGRATION_TEST_MAX_CONCURRENCY:-"-1"}
+LOG_LEVEL=${LOG_LEVEL:-2}
+KUBE_TEST_ARGS=${KUBE_TEST_ARGS:-}
+
+kube::test::find_integration_test_dirs() {
+  (
+    cd ${KUBE_ROOT}
+    find test/integration/${1-} -name '*_test.go' -print0 \
+      | xargs -0n1 dirname | sed "s|^|${KUBE_GO_PACKAGE}/|" \
+      | LC_ALL=C sort -u
+  )
+}
+
+cleanup() {
+  kube::log::status "Cleaning up etcd"
+  kube::etcd::cleanup
+  kube::log::status "Integration test cleanup complete"
+}
+
+runTests() {
+  kube::log::status "Starting etcd instance"
+  kube::etcd::start
+  kube::log::status "Running integration test cases"
+
+  # TODO: Re-enable race detection when we switch to a thread-safe etcd client
+  # KUBE_RACE="-race"
+  make -C "${KUBE_ROOT}" test \
+      WHAT="$(kube::test::find_integration_test_dirs ${2-} | paste -sd' ' -) $(echo ${@:3})" \
+      KUBE_GOFLAGS="${KUBE_GOFLAGS:-} -tags 'integration no-docker'" \
+      KUBE_TEST_ARGS="${KUBE_TEST_ARGS:-} ${SHORT:--short=true} --vmodule=garbage*collector*=6 --alsologtostderr=true" \
+      KUBE_RACE="" \
+      KUBE_TIMEOUT="${KUBE_TIMEOUT}" \
+      KUBE_TEST_API_VERSIONS="$1"
+
+  cleanup
+}
+
+checkEtcdOnPath() {
+  kube::log::status "Checking etcd is on PATH"
+  which etcd && return
+  kube::log::status "Cannot find etcd, cannot run integration tests."
+  kube::log::status "Please see docs/devel/testing.md for instructions."
+  return 1
+}
+
+checkEtcdOnPath
+
+# Run cleanup to stop etcd on interrupt or other kill signal.
+trap cleanup EXIT
+
+# If a test case is specified, just run once with v1 API version and exit
+if [[ -n "${KUBE_TEST_ARGS}" ]]; then
+  runTests v1
+fi
+
+# Pass arguments that begin with "-" and move them to goflags.
+what_flags=()
+for arg in "$@"; do
+  if [[ "${arg}" == -* ]]; then
+    what_flags+=("${arg}")
+  fi
+done
+if [[ "${#what_flags[@]}" -eq 0 ]]; then
+  what_flags=''
+fi
+
+
+# Convert the CSV to an array of API versions to test
+IFS=';' read -a apiVersions <<< "${KUBE_TEST_API_VERSIONS}"
+for apiVersion in "${apiVersions[@]}"; do
+  runTests "${apiVersion}" "${1-}" "${what_flags[@]}"
+done
--- a/vendor/k8s.io/kubernetes/hack/make-rules/test-kubeadm-cmd.sh
+++ b/vendor/k8s.io/kubernetes/hack/make-rules/test-kubeadm-cmd.sh
@ -0,0 +1,32 @@
+#!/bin/bash
+
+# Copyright 2016 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.
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+KUBE_ROOT=$(dirname "${BASH_SOURCE}")/../..
+source "${KUBE_ROOT}/hack/lib/init.sh"
+
+KUBEADM_PATH="${KUBEADM_PATH:=$(kube::realpath "${KUBE_ROOT}")/cluster/kubeadm.sh}"
+
+# If testing a different version of kubeadm than the current build, you can
+# comment this out to save yourself from needlessly building here.
+make -C "${KUBE_ROOT}" WHAT=cmd/kubeadm
+
+make -C "${KUBE_ROOT}" test \
+  WHAT=k8s.io/kubernetes/cmd/kubeadm/test \
+  KUBE_TEST_ARGS="--kubeadm-path '${KUBEADM_PATH}'"
--- a/vendor/k8s.io/kubernetes/hack/make-rules/test.sh
+++ b/vendor/k8s.io/kubernetes/hack/make-rules/test.sh
@ -0,0 +1,338 @@
+#!/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.
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+KUBE_ROOT=$(dirname "${BASH_SOURCE}")/../..
+source "${KUBE_ROOT}/hack/lib/init.sh"
+
+kube::golang::setup_env
+
+# start the cache mutation detector by default so that cache mutators will be found
+KUBE_CACHE_MUTATION_DETECTOR="${KUBE_CACHE_MUTATION_DETECTOR:-true}"
+export KUBE_CACHE_MUTATION_DETECTOR
+
+kube::test::find_dirs() {
+  (
+    cd ${KUBE_ROOT}
+    find -L . -not \( \
+        \( \
+          -path './_artifacts/*' \
+          -o -path './_output/*' \
+          -o -path './_gopath/*' \
+          -o -path './cmd/kubeadm/test/*' \
+          -o -path './contrib/podex/*' \
+          -o -path './output/*' \
+          -o -path './release/*' \
+          -o -path './target/*' \
+          -o -path './test/e2e/*' \
+          -o -path './test/e2e_node/*' \
+          -o -path './test/integration/*' \
+          -o -path './test/component/scheduler/perf/*' \
+          -o -path './third_party/*' \
+          -o -path './staging/*' \
+          -o -path './vendor/*' \
+        \) -prune \
+      \) -name '*_test.go' -print0 | xargs -0n1 dirname | sed "s|^\./|${KUBE_GO_PACKAGE}/|" | LC_ALL=C sort -u
+
+    find -L . \
+        -path './_output' -prune \
+        -o -path './vendor/k8s.io/client-go/*' \
+        -o -path './vendor/k8s.io/apiserver/*' \
+        -o -path './test/e2e_node/system/*' \
+      -name '*_test.go' -print0 | xargs -0n1 dirname | sed "s|^\./|${KUBE_GO_PACKAGE}/|" | LC_ALL=C sort -u
+
+    # run tests for apiserver
+    find ./staging/src/k8s.io/apiserver -name '*_test.go' \
+      -name '*_test.go' -print0 | xargs -0n1 dirname | sed 's|^\./staging/src/|./vendor/|' | LC_ALL=C sort -u
+
+    # run tests for apimachinery
+    find ./staging/src/k8s.io/apimachinery -name '*_test.go' \
+      -name '*_test.go' -print0 | xargs -0n1 dirname | sed 's|^\./staging/src/|./vendor/|' | LC_ALL=C sort -u
+  )
+}
+
+KUBE_TIMEOUT=${KUBE_TIMEOUT:--timeout 120s}
+KUBE_COVER=${KUBE_COVER:-n} # set to 'y' to enable coverage collection
+KUBE_COVERMODE=${KUBE_COVERMODE:-atomic}
+# How many 'go test' instances to run simultaneously when running tests in
+# coverage mode.
+KUBE_COVERPROCS=${KUBE_COVERPROCS:-4}
+KUBE_RACE=${KUBE_RACE:-}   # use KUBE_RACE="-race" to enable race testing
+# Set to the goveralls binary path to report coverage results to Coveralls.io.
+KUBE_GOVERALLS_BIN=${KUBE_GOVERALLS_BIN:-}
+# Lists of API Versions of each groups that should be tested, groups are
+# separated by comma, lists are separated by semicolon. e.g.,
+# "v1,compute/v1alpha1,experimental/v1alpha2;v1,compute/v2,experimental/v1alpha3"
+# FIXME: due to current implementation of a test client (see: pkg/api/testapi/testapi.go)
+# ONLY the last version is tested in each group.
+ALL_VERSIONS_CSV=$(IFS=',';echo "${KUBE_AVAILABLE_GROUP_VERSIONS[*]// /,}";IFS=$),federation/v1beta1
+KUBE_TEST_API_VERSIONS="${KUBE_TEST_API_VERSIONS:-${ALL_VERSIONS_CSV}}"
+# once we have multiple group supports
+# Create a junit-style XML test report in this directory if set.
+KUBE_JUNIT_REPORT_DIR=${KUBE_JUNIT_REPORT_DIR:-}
+# Set to 'y' to keep the verbose stdout from tests when KUBE_JUNIT_REPORT_DIR is
+# set.
+KUBE_KEEP_VERBOSE_TEST_OUTPUT=${KUBE_KEEP_VERBOSE_TEST_OUTPUT:-n}
+
+kube::test::usage() {
+  kube::log::usage_from_stdin <<EOF
+usage: $0 [OPTIONS] [TARGETS]
+
+OPTIONS:
+  -p <number>   : number of parallel workers, must be >= 1
+EOF
+}
+
+isnum() {
+  [[ "$1" =~ ^[0-9]+$ ]]
+}
+
+PARALLEL="${PARALLEL:-1}"
+while getopts "hp:i:" opt ; do
+  case $opt in
+    h)
+      kube::test::usage
+      exit 0
+      ;;
+    p)
+      PARALLEL="$OPTARG"
+      if ! isnum "${PARALLEL}" || [[ "${PARALLEL}" -le 0 ]]; then
+        kube::log::usage "'$0': argument to -p must be numeric and greater than 0"
+        kube::test::usage
+        exit 1
+      fi
+      ;;
+    i)
+      kube::log::usage "'$0': use GOFLAGS='-count <num-iterations>'"
+      kube::test::usage
+      exit 1
+      ;;
+    ?)
+      kube::test::usage
+      exit 1
+      ;;
+    :)
+      kube::log::usage "Option -$OPTARG <value>"
+      kube::test::usage
+      exit 1
+      ;;
+  esac
+done
+shift $((OPTIND - 1))
+
+# Use eval to preserve embedded quoted strings.
+eval "goflags=(${KUBE_GOFLAGS:-})"
+eval "testargs=(${KUBE_TEST_ARGS:-})"
+
+# Used to filter verbose test output.
+go_test_grep_pattern=".*"
+
+# The go-junit-report tool needs full test case information to produce a
+# meaningful report.
+if [[ -n "${KUBE_JUNIT_REPORT_DIR}" ]] ; then
+  goflags+=(-v)
+  # Show only summary lines by matching lines like "status package/test"
+  go_test_grep_pattern="^[^[:space:]]\+[[:space:]]\+[^[:space:]]\+/[^[[:space:]]\+"
+fi
+
+# Filter out arguments that start with "-" and move them to goflags.
+testcases=()
+for arg; do
+  if [[ "${arg}" == -* ]]; then
+    goflags+=("${arg}")
+  else
+    testcases+=("${arg}")
+  fi
+done
+if [[ ${#testcases[@]} -eq 0 ]]; then
+  testcases=($(kube::test::find_dirs))
+fi
+set -- "${testcases[@]+${testcases[@]}}"
+
+junitFilenamePrefix() {
+  if [[ -z "${KUBE_JUNIT_REPORT_DIR}" ]]; then
+    echo ""
+    return
+  fi
+  mkdir -p "${KUBE_JUNIT_REPORT_DIR}"
+  # This filename isn't parsed by anything, and we must avoid
+  # exceeding 255 character filename limit. KUBE_TEST_API
+  # barely fits there and in coverage mode test names are
+  # appended to generated file names, easily exceeding
+  # 255 chars in length. So let's just sha1sum it.
+  local KUBE_TEST_API_HASH="$(echo -n "${KUBE_TEST_API//\//-}"|sha1sum|awk '{print $1}')"
+  echo "${KUBE_JUNIT_REPORT_DIR}/junit_${KUBE_TEST_API_HASH}_$(kube::util::sortable_date)"
+}
+
+produceJUnitXMLReport() {
+  local -r junit_filename_prefix=$1
+  if [[ -z "${junit_filename_prefix}" ]]; then
+    return
+  fi
+
+  local test_stdout_filenames
+  local junit_xml_filename
+  test_stdout_filenames=$(ls ${junit_filename_prefix}*.stdout)
+  junit_xml_filename="${junit_filename_prefix}.xml"
+  if ! command -v go-junit-report >/dev/null 2>&1; then
+    kube::log::error "go-junit-report not found; please install with " \
+      "go get -u github.com/jstemmer/go-junit-report"
+    return
+  fi
+  cat ${test_stdout_filenames} | go-junit-report > "${junit_xml_filename}"
+  if [[ ! ${KUBE_KEEP_VERBOSE_TEST_OUTPUT} =~ ^[yY]$ ]]; then
+    rm ${test_stdout_filenames}
+  fi
+  kube::log::status "Saved JUnit XML test report to ${junit_xml_filename}"
+}
+
+runTests() {
+  local junit_filename_prefix
+  junit_filename_prefix=$(junitFilenamePrefix)
+
+  # If we're not collecting coverage, run all requested tests with one 'go test'
+  # command, which is much faster.
+  if [[ ! ${KUBE_COVER} =~ ^[yY]$ ]]; then
+    kube::log::status "Running tests without code coverage"
+    # `go test` does not install the things it builds. `go test -i` installs
+    # the build artifacts but doesn't run the tests.  The two together provide
+    # a large speedup for tests that do not need to be rebuilt.
+    go test -i "${goflags[@]:+${goflags[@]}}" \
+      ${KUBE_RACE} ${KUBE_TIMEOUT} "${@}" \
+     "${testargs[@]:+${testargs[@]}}"
+    go test "${goflags[@]:+${goflags[@]}}" \
+      ${KUBE_RACE} ${KUBE_TIMEOUT} "${@}" \
+     "${testargs[@]:+${testargs[@]}}" \
+     | tee ${junit_filename_prefix:+"${junit_filename_prefix}.stdout"} \
+     | grep "${go_test_grep_pattern}" && rc=$? || rc=$?
+    produceJUnitXMLReport "${junit_filename_prefix}"
+    return ${rc}
+  fi
+
+  # Create coverage report directories.
+  cover_report_dir="/tmp/k8s_coverage/${KUBE_TEST_API}/$(kube::util::sortable_date)"
+  cover_profile="coverage.out"  # Name for each individual coverage profile
+  kube::log::status "Saving coverage output in '${cover_report_dir}'"
+  mkdir -p "${@+${@/#/${cover_report_dir}/}}"
+
+  # Run all specified tests, collecting coverage results. Go currently doesn't
+  # support collecting coverage across multiple packages at once, so we must issue
+  # separate 'go test' commands for each package and then combine at the end.
+  # To speed things up considerably, we can at least use xargs -P to run multiple
+  # 'go test' commands at once.
+  # To properly parse the test results if generating a JUnit test report, we
+  # must make sure the output from PARALLEL runs is not mixed. To achieve this,
+  # we spawn a subshell for each PARALLEL process, redirecting the output to
+  # separate files.
+
+  # ignore paths:
+  # cmd/libs/go2idl/generator: is fragile when run under coverage, so ignore it for now.
+  #                            https://github.com/kubernetes/kubernetes/issues/24967
+  # vendor/k8s.io/client-go/1.4/rest: causes cover internal errors
+  #                            https://github.com/golang/go/issues/16540
+  cover_ignore_dirs="cmd/libs/go2idl/generator|vendor/k8s.io/client-go/1.4/rest"
+  for path in $(echo $cover_ignore_dirs | sed 's/|/ /g'); do
+      echo -e "skipped\tk8s.io/kubernetes/$path"
+  done
+  #
+  # `go test` does not install the things it builds. `go test -i` installs
+  # the build artifacts but doesn't run the tests.  The two together provide
+  # a large speedup for tests that do not need to be rebuilt.
+  printf "%s\n" "${@}" \
+    | grep -Ev $cover_ignore_dirs \
+    | xargs -I{} -n 1 -P ${KUBE_COVERPROCS} \
+    bash -c "set -o pipefail; _pkg=\"\$0\"; _pkg_out=\${_pkg//\//_}; \
+      go test -i ${goflags[@]:+${goflags[@]}} \
+        ${KUBE_RACE} \
+        ${KUBE_TIMEOUT} \
+        -cover -covermode=\"${KUBE_COVERMODE}\" \
+        -coverprofile=\"${cover_report_dir}/\${_pkg}/${cover_profile}\" \
+        \"\${_pkg}\" \
+        ${testargs[@]:+${testargs[@]}}
+      go test ${goflags[@]:+${goflags[@]}} \
+        ${KUBE_RACE} \
+        ${KUBE_TIMEOUT} \
+        -cover -covermode=\"${KUBE_COVERMODE}\" \
+        -coverprofile=\"${cover_report_dir}/\${_pkg}/${cover_profile}\" \
+        \"\${_pkg}\" \
+        ${testargs[@]:+${testargs[@]}} \
+      | tee ${junit_filename_prefix:+\"${junit_filename_prefix}-\$_pkg_out.stdout\"} \
+      | grep \"${go_test_grep_pattern}\"" \
+    {} \
+    && test_result=$? || test_result=$?
+
+  produceJUnitXMLReport "${junit_filename_prefix}"
+
+  COMBINED_COVER_PROFILE="${cover_report_dir}/combined-coverage.out"
+  {
+    # The combined coverage profile needs to start with a line indicating which
+    # coverage mode was used (set, count, or atomic). This line is included in
+    # each of the coverage profiles generated when running 'go test -cover', but
+    # we strip these lines out when combining so that there's only one.
+    echo "mode: ${KUBE_COVERMODE}"
+
+    # 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
+    done
+  } >"${COMBINED_COVER_PROFILE}"
+
+  coverage_html_file="${cover_report_dir}/combined-coverage.html"
+  go tool cover -html="${COMBINED_COVER_PROFILE}" -o="${coverage_html_file}"
+  kube::log::status "Combined coverage report: ${coverage_html_file}"
+
+  return ${test_result}
+}
+
+reportCoverageToCoveralls() {
+  if [[ ${KUBE_COVER} =~ ^[yY]$ ]] && [[ -x "${KUBE_GOVERALLS_BIN}" ]]; then
+    kube::log::status "Reporting coverage results to Coveralls for service ${CI_NAME:-}"
+    ${KUBE_GOVERALLS_BIN} -coverprofile="${COMBINED_COVER_PROFILE}" \
+    ${CI_NAME:+"-service=${CI_NAME}"} \
+    ${COVERALLS_REPO_TOKEN:+"-repotoken=${COVERALLS_REPO_TOKEN}"} \
+      || true
+  fi
+}
+
+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";
+  fi
+}
+
+checkFDs
+
+
+# Convert the CSVs to arrays.
+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"
+  # KUBE_TEST_API sets the version of each group to be tested.
+  KUBE_TEST_API="${apiVersion}" runTests "$@"
+done
+
+# We might run the tests for multiple versions, but we want to report only
+# one of them to coveralls. Here we report coverage from the last run.
+reportCoverageToCoveralls
--- a/vendor/k8s.io/kubernetes/hack/make-rules/verify.sh
+++ b/vendor/k8s.io/kubernetes/hack/make-rules/verify.sh
@ -0,0 +1,96 @@
+#!/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.
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+KUBE_ROOT=$(dirname "${BASH_SOURCE}")/../..
+source "${KUBE_ROOT}/cluster/lib/util.sh"
+
+# Excluded checks are always skipped.
+EXCLUDED_CHECKS=(
+  "verify-linkcheck.sh"  # runs in separate Jenkins job once per day due to high network usage
+  "verify-govet.sh"      # it has a separate make vet target
+  "verify-staging-client-go.sh" # TODO: enable the script after 1.5 code freeze
+  "verify-test-owners.sh"  # TODO(rmmh): figure out how to avoid endless conflicts
+  )
+
+function is-excluded {
+  if [[ $1 -ef "$KUBE_ROOT/hack/verify-all.sh" ]]; then
+    return
+  fi
+  for e in ${EXCLUDED_CHECKS[@]}; do
+    if [[ $1 -ef "$KUBE_ROOT/hack/$e" ]]; then
+      return
+    fi
+  done
+  return 1
+}
+
+function run-cmd {
+  if ${SILENT}; then
+    "$@" &> /dev/null
+  else
+    "$@"
+  fi
+}
+
+function run-checks {
+  local -r pattern=$1
+  local -r runner=$2
+
+  for t in $(ls ${pattern})
+  do
+    if is-excluded "${t}" ; then
+      echo "Skipping ${t}"
+      continue
+    fi
+    echo -e "Verifying ${t}"
+    local start=$(date +%s)
+    run-cmd "${runner}" "${t}" && tr=$? || tr=$?
+    local elapsed=$(($(date +%s) - ${start}))
+    if [[ ${tr} -eq 0 ]]; then
+      echo -e "${color_green}SUCCESS${color_norm}  ${t}\t${elapsed}s"
+    else
+      echo -e "${color_red}FAILED${color_norm}   ${t}\t${elapsed}s"
+      ret=1
+    fi
+  done
+}
+
+while getopts ":v" opt; do
+  case ${opt} in
+    v)
+      SILENT=false
+      ;;
+    \?)
+      echo "Invalid flag: -${OPTARG}" >&2
+      exit 1
+      ;;
+  esac
+done
+
+if ${SILENT} ; then
+  echo "Running in silent mode, run with -v if you want to see script logs."
+fi
+
+ret=0
+run-checks "${KUBE_ROOT}/hack/verify-*.sh" bash
+run-checks "${KUBE_ROOT}/hack/verify-*.py" python
+exit ${ret}
+
+# ex: ts=2 sw=2 et filetype=sh
--- a/vendor/k8s.io/kubernetes/hack/make-rules/vet.sh
+++ b/vendor/k8s.io/kubernetes/hack/make-rules/vet.sh
@ -0,0 +1,50 @@
+#!/bin/bash
+
+# Copyright 2016 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.
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+KUBE_ROOT=$(dirname "${BASH_SOURCE}")/../..
+source "${KUBE_ROOT}/hack/lib/init.sh"
+
+cd "${KUBE_ROOT}"
+
+# This is required before we run govet for the results to be correct.
+# See https://github.com/golang/go/issues/16086 for details.
+make generated_files
+go install ./cmd/...
+
+# Use eval to preserve embedded quoted strings.
+eval "goflags=(${KUBE_GOFLAGS:-})"
+
+# Filter out arguments that start with "-" and move them to goflags.
+targets=()
+for arg; do
+  if [[ "${arg}" == -* ]]; then
+    goflags+=("${arg}")
+  else
+    targets+=("${arg}")
+  fi
+done
+
+if [[ ${#targets[@]} -eq 0 ]]; then
+  # Do not run on third_party directories or generated client code.
+  targets=$(go list -e ./... | egrep -v "/(third_party|vendor|staging|clientset_generated)/")
+fi
+
+set -x
+go vet "${goflags[@]:+${goflags[@]}}" ${targets[@]}