Replace godep with dep

vendor/k8s.io/kubernetes/test/utils/BUILD

@@ -0,0 +1,65 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "conditions.go",
+        "density_utils.go",
+        "deployment.go",
+        "pod_store.go",
+        "runners.go",
+        "tmpdir.go",
+    ],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/api/v1/pod:go_default_library",
+        "//pkg/apis/batch:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset:go_default_library",
+        "//pkg/controller/deployment/util:go_default_library",
+        "//pkg/util/labels:go_default_library",
+        "//vendor/github.com/davecgh/go-spew/spew:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/api/batch/v1:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/api/extensions/v1beta1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/equality:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/fields:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/uuid:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+        "//vendor/k8s.io/client-go/util/workqueue:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//test/utils/image:all-srcs",
+        "//test/utils/junit:all-srcs",
+    ],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/test/utils/conditions.go

@@ -0,0 +1,122 @@
+/*
+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.
+*/
+
+package utils
+
+import (
+	"fmt"
+
+	"k8s.io/api/core/v1"
+)
+
+type ContainerFailures struct {
+	status   *v1.ContainerStateTerminated
+	Restarts int
+}
+
+// PodRunningReady checks whether pod p's phase is running and it has a ready
+// condition of status true.
+func PodRunningReady(p *v1.Pod) (bool, error) {
+	// Check the phase is running.
+	if p.Status.Phase != v1.PodRunning {
+		return false, fmt.Errorf("want pod '%s' on '%s' to be '%v' but was '%v'",
+			p.ObjectMeta.Name, p.Spec.NodeName, v1.PodRunning, p.Status.Phase)
+	}
+	// Check the ready condition is true.
+	if !PodReady(p) {
+		return false, fmt.Errorf("pod '%s' on '%s' didn't have condition {%v %v}; conditions: %v",
+			p.ObjectMeta.Name, p.Spec.NodeName, v1.PodReady, v1.ConditionTrue, p.Status.Conditions)
+	}
+	return true, nil
+}
+
+func PodRunningReadyOrSucceeded(p *v1.Pod) (bool, error) {
+	// Check if the phase is succeeded.
+	if p.Status.Phase == v1.PodSucceeded {
+		return true, nil
+	}
+	return PodRunningReady(p)
+}
+
+// FailedContainers inspects all containers in a pod and returns failure
+// information for containers that have failed or been restarted.
+// A map is returned where the key is the containerID and the value is a
+// struct containing the restart and failure information
+func FailedContainers(pod *v1.Pod) map[string]ContainerFailures {
+	var state ContainerFailures
+	states := make(map[string]ContainerFailures)
+
+	statuses := pod.Status.ContainerStatuses
+	if len(statuses) == 0 {
+		return nil
+	} else {
+		for _, status := range statuses {
+			if status.State.Terminated != nil {
+				states[status.ContainerID] = ContainerFailures{status: status.State.Terminated}
+			} else if status.LastTerminationState.Terminated != nil {
+				states[status.ContainerID] = ContainerFailures{status: status.LastTerminationState.Terminated}
+			}
+			if status.RestartCount > 0 {
+				var ok bool
+				if state, ok = states[status.ContainerID]; !ok {
+					state = ContainerFailures{}
+				}
+				state.Restarts = int(status.RestartCount)
+				states[status.ContainerID] = state
+			}
+		}
+	}
+
+	return states
+}
+
+// TerminatedContainers inspects all containers in a pod and returns a map
+// of "container name: termination reason", for all currently terminated
+// containers.
+func TerminatedContainers(pod *v1.Pod) map[string]string {
+	states := make(map[string]string)
+	statuses := pod.Status.ContainerStatuses
+	if len(statuses) == 0 {
+		return states
+	}
+	for _, status := range statuses {
+		if status.State.Terminated != nil {
+			states[status.Name] = status.State.Terminated.Reason
+		}
+	}
+	return states
+}
+
+// PodNotReady checks whether pod p's has a ready condition of status false.
+func PodNotReady(p *v1.Pod) (bool, error) {
+	// Check the ready condition is false.
+	if PodReady(p) {
+		return false, fmt.Errorf("pod '%s' on '%s' didn't have condition {%v %v}; conditions: %v",
+			p.ObjectMeta.Name, p.Spec.NodeName, v1.PodReady, v1.ConditionFalse, p.Status.Conditions)
+	}
+	return true, nil
+}
+
+// podReady returns whether pod has a condition of Ready with a status of true.
+// TODO: should be replaced with podutil.IsPodReady
+func PodReady(pod *v1.Pod) bool {
+	for _, cond := range pod.Status.Conditions {
+		if cond.Type == v1.PodReady && cond.Status == v1.ConditionTrue {
+			return true
+		}
+	}
+	return false
+}

vendor/k8s.io/kubernetes/test/utils/density_utils.go

@@ -0,0 +1,105 @@
+/*
+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.
+*/
+
+package utils
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/golang/glog"
+	"k8s.io/api/core/v1"
+	apierrs "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	clientset "k8s.io/client-go/kubernetes"
+)
+
+const (
+	retries = 5
+)
+
+func AddLabelsToNode(c clientset.Interface, nodeName string, labels map[string]string) error {
+	tokens := make([]string, 0, len(labels))
+	for k, v := range labels {
+		tokens = append(tokens, "\""+k+"\":\""+v+"\"")
+	}
+	labelString := "{" + strings.Join(tokens, ",") + "}"
+	patch := fmt.Sprintf(`{"metadata":{"labels":%v}}`, labelString)
+	var err error
+	for attempt := 0; attempt < retries; attempt++ {
+		_, err = c.Core().Nodes().Patch(nodeName, types.MergePatchType, []byte(patch))
+		if err != nil {
+			if !apierrs.IsConflict(err) {
+				return err
+			}
+		} else {
+			break
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+	return err
+}
+
+// RemoveLabelOffNode is for cleaning up labels temporarily added to node,
+// won't fail if target label doesn't exist or has been removed.
+func RemoveLabelOffNode(c clientset.Interface, nodeName string, labelKeys []string) error {
+	var node *v1.Node
+	var err error
+	for attempt := 0; attempt < retries; attempt++ {
+		node, err = c.Core().Nodes().Get(nodeName, metav1.GetOptions{})
+		if err != nil {
+			return err
+		}
+		if node.Labels == nil {
+			return nil
+		}
+		for _, labelKey := range labelKeys {
+			if node.Labels == nil || len(node.Labels[labelKey]) == 0 {
+				break
+			}
+			delete(node.Labels, labelKey)
+		}
+		_, err = c.Core().Nodes().Update(node)
+		if err != nil {
+			if !apierrs.IsConflict(err) {
+				return err
+			} else {
+				glog.V(2).Infof("Conflict when trying to remove a labels %v from %v", labelKeys, nodeName)
+			}
+		} else {
+			break
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+	return err
+}
+
+// VerifyLabelsRemoved checks if Node for given nodeName does not have any of labels from labelKeys.
+// Return non-nil error if it does.
+func VerifyLabelsRemoved(c clientset.Interface, nodeName string, labelKeys []string) error {
+	node, err := c.Core().Nodes().Get(nodeName, metav1.GetOptions{})
+	if err != nil {
+		return err
+	}
+	for _, labelKey := range labelKeys {
+		if node.Labels != nil && len(node.Labels[labelKey]) != 0 {
+			return fmt.Errorf("Failed removing label " + labelKey + " of the node " + nodeName)
+		}
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/test/utils/deployment.go

@@ -0,0 +1,246 @@
+/*
+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.
+*/
+
+package utils
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/davecgh/go-spew/spew"
+
+	"k8s.io/api/core/v1"
+	extensions "k8s.io/api/extensions/v1beta1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/wait"
+	clientset "k8s.io/client-go/kubernetes"
+	podutil "k8s.io/kubernetes/pkg/api/v1/pod"
+	deploymentutil "k8s.io/kubernetes/pkg/controller/deployment/util"
+	labelsutil "k8s.io/kubernetes/pkg/util/labels"
+)
+
+type LogfFn func(format string, args ...interface{})
+
+func LogReplicaSetsOfDeployment(deployment *extensions.Deployment, allOldRSs []*extensions.ReplicaSet, newRS *extensions.ReplicaSet, logf LogfFn) {
+	if newRS != nil {
+		logf(spew.Sprintf("New ReplicaSet %q of Deployment %q:\n%+v", newRS.Name, deployment.Name, *newRS))
+	} else {
+		logf("New ReplicaSet of Deployment %q is nil.", deployment.Name)
+	}
+	if len(allOldRSs) > 0 {
+		logf("All old ReplicaSets of Deployment %q:", deployment.Name)
+	}
+	for i := range allOldRSs {
+		logf(spew.Sprintf("%+v", *allOldRSs[i]))
+	}
+}
+
+func LogPodsOfDeployment(c clientset.Interface, deployment *extensions.Deployment, rsList []*extensions.ReplicaSet, logf LogfFn) {
+	minReadySeconds := deployment.Spec.MinReadySeconds
+	podListFunc := func(namespace string, options metav1.ListOptions) (*v1.PodList, error) {
+		return c.Core().Pods(namespace).List(options)
+	}
+
+	podList, err := deploymentutil.ListPods(deployment, rsList, podListFunc)
+	if err != nil {
+		logf("Failed to list Pods of Deployment %q: %v", deployment.Name, err)
+		return
+	}
+	for _, pod := range podList.Items {
+		availability := "not available"
+		if podutil.IsPodAvailable(&pod, minReadySeconds, metav1.Now()) {
+			availability = "available"
+		}
+		logf(spew.Sprintf("Pod %q is %s:\n%+v", pod.Name, availability, pod))
+	}
+}
+
+// Waits for the deployment status to become valid (i.e. max unavailable and max surge aren't violated anymore).
+// Note that the status should stay valid at all times unless shortly after a scaling event or the deployment is just created.
+// To verify that the deployment status is valid and wait for the rollout to finish, use WaitForDeploymentStatus instead.
+func WaitForDeploymentStatusValid(c clientset.Interface, d *extensions.Deployment, logf LogfFn, pollInterval, pollTimeout time.Duration) error {
+	var (
+		oldRSs, allOldRSs, allRSs []*extensions.ReplicaSet
+		newRS                     *extensions.ReplicaSet
+		deployment                *extensions.Deployment
+		reason                    string
+	)
+
+	err := wait.Poll(pollInterval, pollTimeout, func() (bool, error) {
+		var err error
+		deployment, err = c.Extensions().Deployments(d.Namespace).Get(d.Name, metav1.GetOptions{})
+		if err != nil {
+			return false, err
+		}
+		oldRSs, allOldRSs, newRS, err = deploymentutil.GetAllReplicaSets(deployment, c.ExtensionsV1beta1())
+		if err != nil {
+			return false, err
+		}
+		if newRS == nil {
+			// New RC hasn't been created yet.
+			reason = "new replica set hasn't been created yet"
+			logf(reason)
+			return false, nil
+		}
+		allRSs = append(oldRSs, newRS)
+		// The old/new ReplicaSets need to contain the pod-template-hash label
+		for i := range allRSs {
+			if !labelsutil.SelectorHasLabel(allRSs[i].Spec.Selector, extensions.DefaultDeploymentUniqueLabelKey) {
+				reason = "all replica sets need to contain the pod-template-hash label"
+				logf(reason)
+				return false, nil
+			}
+		}
+		totalCreated := deploymentutil.GetReplicaCountForReplicaSets(allRSs)
+		maxCreated := *(deployment.Spec.Replicas) + deploymentutil.MaxSurge(*deployment)
+		if totalCreated > maxCreated {
+			reason = fmt.Sprintf("total pods created: %d, more than the max allowed: %d", totalCreated, maxCreated)
+			logf(reason)
+			return false, nil
+		}
+		minAvailable := deploymentutil.MinAvailable(deployment)
+		if deployment.Status.AvailableReplicas < minAvailable {
+			reason = fmt.Sprintf("total pods available: %d, less than the min required: %d", deployment.Status.AvailableReplicas, minAvailable)
+			logf(reason)
+			return false, nil
+		}
+
+		// When the deployment status and its underlying resources reach the desired state, we're done
+		if deploymentutil.DeploymentComplete(deployment, &deployment.Status) {
+			return true, nil
+		}
+
+		reason = fmt.Sprintf("deployment status: %#v", deployment.Status)
+		logf(reason)
+
+		return false, nil
+	})
+
+	if err == wait.ErrWaitTimeout {
+		LogReplicaSetsOfDeployment(deployment, allOldRSs, newRS, logf)
+		LogPodsOfDeployment(c, deployment, allRSs, logf)
+		err = fmt.Errorf("%s", reason)
+	}
+	if err != nil {
+		return fmt.Errorf("error waiting for deployment %q status to match expectation: %v", d.Name, err)
+	}
+	return nil
+}
+
+// WaitForDeploymentRevisionAndImage waits for the deployment's and its new RS's revision and container image to match the given revision and image.
+// Note that deployment revision and its new RS revision should be updated shortly, so we only wait for 1 minute here to fail early.
+func WaitForDeploymentRevisionAndImage(c clientset.Interface, ns, deploymentName string, revision, image string, logf LogfFn, pollInterval, pollTimeout time.Duration) error {
+	var deployment *extensions.Deployment
+	var newRS *extensions.ReplicaSet
+	var reason string
+	err := wait.Poll(pollInterval, pollTimeout, func() (bool, error) {
+		var err error
+		deployment, err = c.Extensions().Deployments(ns).Get(deploymentName, metav1.GetOptions{})
+		if err != nil {
+			return false, err
+		}
+		// The new ReplicaSet needs to be non-nil and contain the pod-template-hash label
+
+		newRS, err = deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
+
+		if err != nil {
+			return false, err
+		}
+		if newRS == nil {
+			reason = fmt.Sprintf("New replica set for deployment %q is yet to be created", deployment.Name)
+			logf(reason)
+			return false, nil
+		}
+		if !labelsutil.SelectorHasLabel(newRS.Spec.Selector, extensions.DefaultDeploymentUniqueLabelKey) {
+			reason = fmt.Sprintf("New replica set %q doesn't have DefaultDeploymentUniqueLabelKey", newRS.Name)
+			logf(reason)
+			return false, nil
+		}
+		// Check revision of this deployment, and of the new replica set of this deployment
+		if deployment.Annotations == nil || deployment.Annotations[deploymentutil.RevisionAnnotation] != revision {
+			reason = fmt.Sprintf("Deployment %q doesn't have the required revision set", deployment.Name)
+			logf(reason)
+			return false, nil
+		}
+		if !containsImage(deployment.Spec.Template.Spec.Containers, image) {
+			reason = fmt.Sprintf("Deployment %q doesn't have the required image %s set", deployment.Name, image)
+			logf(reason)
+			return false, nil
+		}
+		if newRS.Annotations == nil || newRS.Annotations[deploymentutil.RevisionAnnotation] != revision {
+			reason = fmt.Sprintf("New replica set %q doesn't have the required revision set", newRS.Name)
+			logf(reason)
+			return false, nil
+		}
+		if !containsImage(newRS.Spec.Template.Spec.Containers, image) {
+			reason = fmt.Sprintf("New replica set %q doesn't have the required image %s.", newRS.Name, image)
+			logf(reason)
+			return false, nil
+		}
+		return true, nil
+	})
+	if err == wait.ErrWaitTimeout {
+		LogReplicaSetsOfDeployment(deployment, nil, newRS, logf)
+		err = fmt.Errorf(reason)
+	}
+	if newRS == nil {
+		return fmt.Errorf("deployment %q failed to create new replica set", deploymentName)
+	}
+	if err != nil {
+		return fmt.Errorf("error waiting for deployment %q (got %s / %s) and new replica set %q (got %s / %s) revision and image to match expectation (expected %s / %s): %v", deploymentName, deployment.Annotations[deploymentutil.RevisionAnnotation], deployment.Spec.Template.Spec.Containers[0].Image, newRS.Name, newRS.Annotations[deploymentutil.RevisionAnnotation], newRS.Spec.Template.Spec.Containers[0].Image, revision, image, err)
+	}
+	return nil
+}
+
+func containsImage(containers []v1.Container, imageName string) bool {
+	for _, container := range containers {
+		if container.Image == imageName {
+			return true
+		}
+	}
+	return false
+}
+
+type UpdateDeploymentFunc func(d *extensions.Deployment)
+
+func UpdateDeploymentWithRetries(c clientset.Interface, namespace, name string, applyUpdate UpdateDeploymentFunc, logf LogfFn) (*extensions.Deployment, error) {
+	var deployment *extensions.Deployment
+	var updateErr error
+	pollErr := wait.PollImmediate(1*time.Second, 1*time.Minute, func() (bool, error) {
+		var err error
+		if deployment, err = c.Extensions().Deployments(namespace).Get(name, metav1.GetOptions{}); err != nil {
+			return false, err
+		}
+		// Apply the update, then attempt to push it to the apiserver.
+		applyUpdate(deployment)
+		if deployment, err = c.Extensions().Deployments(namespace).Update(deployment); err == nil {
+			logf("Updating deployment %s", name)
+			return true, nil
+		}
+		updateErr = err
+		return false, nil
+	})
+	if pollErr == wait.ErrWaitTimeout {
+		pollErr = fmt.Errorf("couldn't apply the provided updated to deployment %q: %v", name, updateErr)
+	}
+	return deployment, pollErr
+}
+
+func WaitForObservedDeployment(c clientset.Interface, ns, deploymentName string, desiredGeneration int64) error {
+	return deploymentutil.WaitForObservedDeployment(func() (*extensions.Deployment, error) {
+		return c.Extensions().Deployments(ns).Get(deploymentName, metav1.GetOptions{})
+	}, desiredGeneration, 2*time.Second, 1*time.Minute)
+}

vendor/k8s.io/kubernetes/test/utils/image/BUILD

@@ -0,0 +1,27 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["manifest.go"],
+    tags = ["automanaged"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/test/utils/image/manifest.go

@@ -0,0 +1,105 @@
+/*
+Copyright 2017 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.
+*/
+
+package image
+
+import (
+	"fmt"
+	"runtime"
+)
+
+const (
+	e2eRegistry     = "gcr.io/kubernetes-e2e-test-images"
+	gcRegistry      = "gcr.io/google-containers"
+	PrivateRegistry = "gcr.io/k8s-authenticated-test"
+	sampleRegistry  = "gcr.io/google-samples"
+)
+
+type ImageConfig struct {
+	registry string
+	name     string
+	version  string
+}
+
+func (i *ImageConfig) SetRegistry(registry string) {
+	i.registry = registry
+}
+
+func (i *ImageConfig) SetName(name string) {
+	i.name = name
+}
+
+func (i *ImageConfig) SetVersion(version string) {
+	i.version = version
+}
+
+var (
+	ClusterTester      = ImageConfig{e2eRegistry, "clusterapi-tester", "1.0"}
+	CudaVectorAdd      = ImageConfig{e2eRegistry, "cuda-vector-add", "1.0"}
+	Dnsutils           = ImageConfig{e2eRegistry, "dnsutils", "1.0"}
+	EntrypointTester   = ImageConfig{e2eRegistry, "entrypoint-tester", "1.0"}
+	Fakegitserver      = ImageConfig{e2eRegistry, "fakegitserver", "1.0"}
+	GBFrontend         = ImageConfig{sampleRegistry, "gb-frontend", "v5"}
+	GBRedisSlave       = ImageConfig{sampleRegistry, "gb-redisslave", "v2"}
+	Goproxy            = ImageConfig{e2eRegistry, "goproxy", "1.0"}
+	Hostexec           = ImageConfig{e2eRegistry, "hostexec", "1.0"}
+	Iperf              = ImageConfig{e2eRegistry, "iperf", "1.0"}
+	JessieDnsutils     = ImageConfig{e2eRegistry, "jessie-dnsutils", "1.0"}
+	Kitten             = ImageConfig{e2eRegistry, "kitten", "1.0"}
+	Liveness           = ImageConfig{e2eRegistry, "liveness", "1.0"}
+	LogsGenerator      = ImageConfig{e2eRegistry, "logs-generator", "1.0"}
+	Mounttest          = ImageConfig{e2eRegistry, "mounttest", "1.0"}
+	MounttestUser      = ImageConfig{e2eRegistry, "mounttest-user", "1.0"}
+	Nautilus           = ImageConfig{e2eRegistry, "nautilus", "1.0"}
+	Net                = ImageConfig{e2eRegistry, "net", "1.0"}
+	Netexec            = ImageConfig{e2eRegistry, "netexec", "1.0"}
+	Nettest            = ImageConfig{e2eRegistry, "nettest", "1.0"}
+	NginxSlim          = ImageConfig{gcRegistry, "nginx-slim", "0.20"}
+	NginxSlimNew       = ImageConfig{gcRegistry, "nginx-slim", "0.21"}
+	NoSnatTest         = ImageConfig{e2eRegistry, "no-snat-test", "1.0"}
+	NoSnatTestProxy    = ImageConfig{e2eRegistry, "no-snat-test-proxy", "1.0"}
+	NWayHTTP           = ImageConfig{e2eRegistry, "n-way-http", "1.0"}
+	Pause              = ImageConfig{gcRegistry, "pause", "3.0"}
+	Porter             = ImageConfig{e2eRegistry, "porter", "1.0"}
+	PortForwardTester  = ImageConfig{e2eRegistry, "port-forward-tester", "1.0"}
+	Redis              = ImageConfig{e2eRegistry, "redis", "1.0"}
+	ResourceConsumer   = ImageConfig{e2eRegistry, "resource-consumer", "1.1"}
+	ResourceController = ImageConfig{e2eRegistry, "resource-consumer/controller", "1.0"}
+	ServeHostname      = ImageConfig{e2eRegistry, "serve-hostname", "1.0"}
+	TestWebserver      = ImageConfig{e2eRegistry, "test-webserver", "1.0"}
+)
+
+func GetE2EImage(image ImageConfig) string {
+	return fmt.Sprintf("%s/%s-%s:%s", image.registry, image.name, runtime.GOARCH, image.version)
+}
+
+// GetBusyboxImage returns multi-arch busybox docker image
+func GetBusyBoxImage() string {
+	switch arch := runtime.GOARCH; arch {
+	case "amd64":
+		return "busybox"
+	case "arm":
+		return "arm32v6/busybox"
+	case "arm64":
+		return "arm64v8/busybox"
+	case "ppc64le":
+		return "ppc64le/busybox"
+	case "s390x":
+		return "s390x/busybox"
+	default:
+		return ""
+	}
+}

vendor/k8s.io/kubernetes/test/utils/junit/BUILD

@@ -0,0 +1,24 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["junit.go"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/test/utils/junit/junit.go

@@ -0,0 +1,104 @@
+/*
+Copyright 2017 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.
+*/
+
+// Package junit provides data structures to allow easy XML encoding
+// and decoding of JUnit test results.
+package junit
+
+import (
+	"encoding/xml"
+	"time"
+)
+
+// TestSuite is a top-level test suite containing test cases.
+type TestSuite struct {
+	XMLName xml.Name `xml:"testsuite"`
+
+	Name      string    `xml:"name,attr"`
+	Tests     int       `xml:"tests,attr"`
+	Disabled  int       `xml:"disabled,attr,omitempty"`
+	Errors    int       `xml:"errors,attr"`
+	Failures  int       `xml:"failures,attr"`
+	Skipped   int       `xml:"skipped,attr,omitempty"`
+	Time      float64   `xml:"time,attr"`
+	Timestamp time.Time `xml:"timestamp,attr"`
+	ID        int       `xml:"id,attr,omitempty"`
+	Package   string    `xml:"package,attr,omitempty"`
+	Hostname  string    `xml:"hostname,attr"`
+
+	Properties []*Property `xml:"properties,omitempty"`
+	TestCases  []*TestCase `xml:"testcase"`
+
+	SystemOut string `xml:"system-out,omitempty"`
+	SystemErr string `xml:"system-err,omitempty"`
+}
+
+// Update iterates through the TestCases and updates Tests, Errors,
+// Failures, and Skipped top level attributes.
+func (t *TestSuite) Update() {
+	t.Tests = len(t.TestCases)
+	for _, tc := range t.TestCases {
+		t.Errors += len(tc.Errors)
+		t.Failures += len(tc.Failures)
+		if len(tc.Skipped) > 0 {
+			t.Skipped++
+		}
+	}
+}
+
+// Property is a simple key-value property that can be attached to a TestSuite.
+type Property struct {
+	XMLName xml.Name `xml:"property"`
+
+	Name  string `xml:"name,attr"`
+	Value string `xml:"value,attr"`
+}
+
+// Error represents the errors in a test case.
+type Error struct {
+	XMLName xml.Name `xml:"error"`
+
+	Message string `xml:"message,attr,omitempty"`
+	Type    string `xml:"type,attr"`
+
+	Value string `xml:",cdata"`
+}
+
+// Failure represents the failures in a test case.
+type Failure struct {
+	XMLName xml.Name `xml:"failure"`
+
+	Message string `xml:"message,attr,omitempty"`
+	Type    string `xml:"type,attr"`
+
+	Value string `xml:",cdata"`
+}
+
+// TestCase represents a single test case within a suite.
+type TestCase struct {
+	XMLName xml.Name `xml:"testcase"`
+
+	Name       string  `xml:"name,attr"`
+	Classname  string  `xml:"classname,attr"`
+	Status     string  `xml:"status,attr,omitempty"`
+	Assertions int     `xml:"assertions,attr,omitempty"`
+	Time       float64 `xml:"time,attr"`
+
+	Skipped string `xml:"skipped,omitempty"`
+
+	Errors   []*Error   `xml:"error,omitempty"`
+	Failures []*Failure `xml:"failure,omitempty"`
+}

vendor/k8s.io/kubernetes/test/utils/pod_store.go

@@ -0,0 +1,69 @@
+/*
+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.
+*/
+
+package utils
+
+import (
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/fields"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/watch"
+	clientset "k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/tools/cache"
+)
+
+// Convenient wrapper around cache.Store that returns list of v1.Pod instead of interface{}.
+type PodStore struct {
+	cache.Store
+	stopCh    chan struct{}
+	Reflector *cache.Reflector
+}
+
+func NewPodStore(c clientset.Interface, namespace string, label labels.Selector, field fields.Selector) *PodStore {
+	lw := &cache.ListWatch{
+		ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
+			options.LabelSelector = label.String()
+			options.FieldSelector = field.String()
+			obj, err := c.Core().Pods(namespace).List(options)
+			return runtime.Object(obj), err
+		},
+		WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
+			options.LabelSelector = label.String()
+			options.FieldSelector = field.String()
+			return c.Core().Pods(namespace).Watch(options)
+		},
+	}
+	store := cache.NewStore(cache.MetaNamespaceKeyFunc)
+	stopCh := make(chan struct{})
+	reflector := cache.NewReflector(lw, &v1.Pod{}, store, 0)
+	go reflector.Run(stopCh)
+	return &PodStore{Store: store, stopCh: stopCh, Reflector: reflector}
+}
+
+func (s *PodStore) List() []*v1.Pod {
+	objects := s.Store.List()
+	pods := make([]*v1.Pod, 0)
+	for _, o := range objects {
+		pods = append(pods, o.(*v1.Pod))
+	}
+	return pods
+}
+
+func (s *PodStore) Stop() {
+	close(s.stopCh)
+}

vendor/k8s.io/kubernetes/test/utils/tmpdir.go

@@ -0,0 +1,38 @@
+/*
+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.
+*/
+
+package utils
+
+import (
+	"io/ioutil"
+	"os"
+
+	"github.com/golang/glog"
+)
+
+func MakeTempDirOrDie(prefix string, baseDir string) string {
+	if baseDir == "" {
+		baseDir = "/tmp"
+	}
+	tempDir, err := ioutil.TempDir(baseDir, prefix)
+	if err != nil {
+		glog.Fatalf("Can't make a temp rootdir: %v", err)
+	}
+	if err = os.MkdirAll(tempDir, 0750); err != nil {
+		glog.Fatalf("Can't mkdir(%q): %v", tempDir, err)
+	}
+	return tempDir
+}