vendor update for E2E framework

Signed-off-by: Madhu Rajanna <madhupr007@gmail.com>

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

@@ -0,0 +1,207 @@
+/*
+Copyright 2018 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 (
+	"bufio"
+	"fmt"
+	"io"
+	"sort"
+	"strings"
+
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/types"
+	auditinternal "k8s.io/apiserver/pkg/apis/audit"
+	"k8s.io/apiserver/pkg/audit"
+)
+
+// AuditEvent is a simplified representation of an audit event for testing purposes
+type AuditEvent struct {
+	ID                 types.UID
+	Level              auditinternal.Level
+	Stage              auditinternal.Stage
+	RequestURI         string
+	Verb               string
+	Code               int32
+	User               string
+	ImpersonatedUser   string
+	ImpersonatedGroups string
+	Resource           string
+	Namespace          string
+	RequestObject      bool
+	ResponseObject     bool
+	AuthorizeDecision  string
+}
+
+// MissingEventsReport provides an analysis if any events are missing
+type MissingEventsReport struct {
+	FirstEventChecked *auditinternal.Event
+	LastEventChecked  *auditinternal.Event
+	NumEventsChecked  int
+	MissingEvents     []AuditEvent
+}
+
+// String returns a human readable string representation of the report
+func (m *MissingEventsReport) String() string {
+	return fmt.Sprintf(`missing %d events
+
+- first event checked: %#v
+
+- last event checked: %#v
+
+- number of events checked: %d
+
+- missing events: %#v`, len(m.MissingEvents), m.FirstEventChecked, m.LastEventChecked, m.NumEventsChecked, m.MissingEvents)
+}
+
+// CheckAuditLines searches the audit log for the expected audit lines.
+func CheckAuditLines(stream io.Reader, expected []AuditEvent, version schema.GroupVersion) (missingReport *MissingEventsReport, err error) {
+	expectations := buildEventExpectations(expected)
+
+	scanner := bufio.NewScanner(stream)
+
+	missingReport = &MissingEventsReport{
+		MissingEvents: expected,
+	}
+
+	var i int
+	for i = 0; scanner.Scan(); i++ {
+		line := scanner.Text()
+
+		e := &auditinternal.Event{}
+		decoder := audit.Codecs.UniversalDecoder(version)
+		if err := runtime.DecodeInto(decoder, []byte(line), e); err != nil {
+			return missingReport, fmt.Errorf("failed decoding buf: %s, apiVersion: %s", line, version)
+		}
+		if i == 0 {
+			missingReport.FirstEventChecked = e
+		}
+		missingReport.LastEventChecked = e
+
+		event, err := testEventFromInternal(e)
+		if err != nil {
+			return missingReport, err
+		}
+
+		// If the event was expected, mark it as found.
+		if _, found := expectations[event]; found {
+			expectations[event] = true
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		return missingReport, err
+	}
+
+	missingEvents := findMissing(expectations)
+	missingReport.MissingEvents = missingEvents
+	missingReport.NumEventsChecked = i
+	return missingReport, nil
+}
+
+// CheckAuditList searches an audit event list for the expected audit events.
+func CheckAuditList(el auditinternal.EventList, expected []AuditEvent) (missing []AuditEvent, err error) {
+	expectations := buildEventExpectations(expected)
+
+	for _, e := range el.Items {
+		event, err := testEventFromInternal(&e)
+		if err != nil {
+			return expected, err
+		}
+
+		// If the event was expected, mark it as found.
+		if _, found := expectations[event]; found {
+			expectations[event] = true
+		}
+	}
+
+	missing = findMissing(expectations)
+	return missing, nil
+}
+
+// CheckForDuplicates checks a list for duplicate events
+func CheckForDuplicates(el auditinternal.EventList) (auditinternal.EventList, error) {
+	// eventMap holds a map of audit events with just a nil value
+	eventMap := map[AuditEvent]*bool{}
+	duplicates := auditinternal.EventList{}
+	var err error
+	for _, e := range el.Items {
+		event, err := testEventFromInternal(&e)
+		if err != nil {
+			return duplicates, err
+		}
+		event.ID = e.AuditID
+		if _, ok := eventMap[event]; ok {
+			duplicates.Items = append(duplicates.Items, e)
+			err = fmt.Errorf("failed duplicate check")
+			continue
+		}
+		eventMap[event] = nil
+	}
+	return duplicates, err
+}
+
+// buildEventExpectations creates a bool map out of a list of audit events
+func buildEventExpectations(expected []AuditEvent) map[AuditEvent]bool {
+	expectations := map[AuditEvent]bool{}
+	for _, event := range expected {
+		expectations[event] = false
+	}
+	return expectations
+}
+
+// testEventFromInternal takes an internal audit event and returns a test event
+func testEventFromInternal(e *auditinternal.Event) (AuditEvent, error) {
+	event := AuditEvent{
+		Level:      e.Level,
+		Stage:      e.Stage,
+		RequestURI: e.RequestURI,
+		Verb:       e.Verb,
+		User:       e.User.Username,
+	}
+	if e.ObjectRef != nil {
+		event.Namespace = e.ObjectRef.Namespace
+		event.Resource = e.ObjectRef.Resource
+	}
+	if e.ResponseStatus != nil {
+		event.Code = e.ResponseStatus.Code
+	}
+	if e.ResponseObject != nil {
+		event.ResponseObject = true
+	}
+	if e.RequestObject != nil {
+		event.RequestObject = true
+	}
+	if e.ImpersonatedUser != nil {
+		event.ImpersonatedUser = e.ImpersonatedUser.Username
+		sort.Strings(e.ImpersonatedUser.Groups)
+		event.ImpersonatedGroups = strings.Join(e.ImpersonatedUser.Groups, ",")
+	}
+	event.AuthorizeDecision = e.Annotations["authorization.k8s.io/decision"]
+	return event, nil
+}
+
+// findMissing checks for false values in the expectations map and returns them as a list
+func findMissing(expectations map[AuditEvent]bool) []AuditEvent {
+	var missing []AuditEvent
+	for event, found := range expectations {
+		if !found {
+			missing = append(missing, event)
+		}
+	}
+	return missing
+}

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

@@ -0,0 +1,193 @@
+/*
+Copyright 2018 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"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	auditregv1alpha1 "k8s.io/api/auditregistration/v1alpha1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/util/wait"
+	auditinternal "k8s.io/apiserver/pkg/apis/audit"
+	auditv1 "k8s.io/apiserver/pkg/apis/audit/v1"
+	"k8s.io/apiserver/pkg/audit"
+)
+
+// AuditTestServer is a helper server for dynamic audit testing
+type AuditTestServer struct {
+	Name            string
+	LockedEventList *LockedEventList
+	Server          *httptest.Server
+	t               *testing.T
+}
+
+// LockedEventList is an event list with a lock for concurrent access
+type LockedEventList struct {
+	*sync.RWMutex
+	EventList auditinternal.EventList
+}
+
+// NewLockedEventList returns a new LockedEventList
+func NewLockedEventList() *LockedEventList {
+	return &LockedEventList{
+		RWMutex:   &sync.RWMutex{},
+		EventList: auditinternal.EventList{},
+	}
+}
+
+// NewAuditTestServer returns a new audit test server
+func NewAuditTestServer(t *testing.T, name string) *AuditTestServer {
+	s := &AuditTestServer{
+		Name:            name,
+		LockedEventList: NewLockedEventList(),
+		t:               t,
+	}
+	s.buildServer()
+	return s
+}
+
+// GetEventList safely returns the internal event list
+func (a *AuditTestServer) GetEventList() auditinternal.EventList {
+	a.LockedEventList.RLock()
+	defer a.LockedEventList.RUnlock()
+	return a.LockedEventList.EventList
+}
+
+// ResetEventList resets the internal event list
+func (a *AuditTestServer) ResetEventList() {
+	a.LockedEventList.Lock()
+	defer a.LockedEventList.Unlock()
+	a.LockedEventList.EventList = auditinternal.EventList{}
+}
+
+// AppendEvents will add the given events to the internal event list
+func (a *AuditTestServer) AppendEvents(events []auditinternal.Event) {
+	a.LockedEventList.Lock()
+	defer a.LockedEventList.Unlock()
+	a.LockedEventList.EventList.Items = append(a.LockedEventList.EventList.Items, events...)
+}
+
+// WaitForEvents waits for the given events to arrive in the server or the 30s timeout is reached
+func (a *AuditTestServer) WaitForEvents(expected []AuditEvent) ([]AuditEvent, error) {
+	var missing []AuditEvent
+	err := wait.PollImmediate(50*time.Millisecond, wait.ForeverTestTimeout, func() (bool, error) {
+		var err error
+		a.LockedEventList.RLock()
+		defer a.LockedEventList.RUnlock()
+		el := a.GetEventList()
+		if len(el.Items) < 1 {
+			return false, nil
+		}
+		missing, err = CheckAuditList(el, expected)
+		if err != nil {
+			return false, nil
+		}
+		return true, nil
+	})
+	return missing, err
+}
+
+// WaitForNumEvents checks that at least the given number of events has arrived or the 30s timeout is reached
+func (a *AuditTestServer) WaitForNumEvents(numEvents int) error {
+	err := wait.PollImmediate(50*time.Millisecond, wait.ForeverTestTimeout, func() (bool, error) {
+		el := a.GetEventList()
+		if len(el.Items) < numEvents {
+			return false, nil
+		}
+		return true, nil
+	})
+	if err != nil {
+		return fmt.Errorf("%v: %d events failed to arrive in %v", err, numEvents, wait.ForeverTestTimeout)
+	}
+	return nil
+}
+
+// Health polls the server healthcheck until successful or the 30s timeout has been reached
+func (a *AuditTestServer) Health() error {
+	err := wait.PollImmediate(100*time.Millisecond, wait.ForeverTestTimeout, func() (bool, error) {
+		resp, err := http.Get(fmt.Sprintf("%s/health", a.Server.URL))
+		if err != nil {
+			return false, nil
+		}
+		if resp.StatusCode != 200 {
+			return false, nil
+		}
+		return true, nil
+	})
+	if err != nil {
+		return fmt.Errorf("server %s permanently failed health check: %v", a.Server.URL, err)
+	}
+	return nil
+}
+
+// Close the server
+func (a *AuditTestServer) Close() {
+	a.Server.Close()
+}
+
+// BuildSinkConfiguration creates a generic audit sink configuration for this server
+func (a *AuditTestServer) BuildSinkConfiguration() *auditregv1alpha1.AuditSink {
+	return &auditregv1alpha1.AuditSink{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: a.Name,
+		},
+		Spec: auditregv1alpha1.AuditSinkSpec{
+			Policy: auditregv1alpha1.Policy{
+				Level: auditregv1alpha1.LevelRequestResponse,
+				Stages: []auditregv1alpha1.Stage{
+					auditregv1alpha1.StageResponseStarted,
+					auditregv1alpha1.StageResponseComplete,
+				},
+			},
+			Webhook: auditregv1alpha1.Webhook{
+				ClientConfig: auditregv1alpha1.WebhookClientConfig{
+					URL: &a.Server.URL,
+				},
+			},
+		},
+	}
+}
+
+// buildServer creates an http test server that will update the internal event list
+// with the value it receives
+func (a *AuditTestServer) buildServer() {
+	decoder := audit.Codecs.UniversalDecoder(auditv1.SchemeGroupVersion)
+	mux := http.NewServeMux()
+	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		body, err := ioutil.ReadAll(r.Body)
+		require.NoError(a.t, err, "could not read request body")
+		el := auditinternal.EventList{}
+		err = runtime.DecodeInto(decoder, body, &el)
+		r.Body.Close()
+		require.NoError(a.t, err, "failed decoding buf: %b, apiVersion: %s", body, auditv1.SchemeGroupVersion)
+		a.AppendEvents(el.Items)
+		w.WriteHeader(200)
+	})
+	mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(200)
+	})
+	a.Server = httptest.NewServer(mux)
+}

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

@@ -0,0 +1,111 @@
+/*
+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"
+	podutil "k8s.io/kubernetes/pkg/api/v1/pod"
+)
+
+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 !podutil.IsPodReady(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
+	}
+	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 podutil.IsPodReady(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
+}

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

@@ -0,0 +1,234 @@
+/*
+Copyright 2018 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.
+*/
+
+// TODO: Refactor common part of functions in this file for generic object kinds.
+
+package utils
+
+import (
+	"fmt"
+	"time"
+
+	apps "k8s.io/api/apps/v1"
+	batch "k8s.io/api/batch/v1"
+	"k8s.io/api/core/v1"
+	apierrs "k8s.io/apimachinery/pkg/api/errors"
+	utilnet "k8s.io/apimachinery/pkg/util/net"
+	"k8s.io/apimachinery/pkg/util/wait"
+	clientset "k8s.io/client-go/kubernetes"
+)
+
+const (
+	// Parameters for retrying with exponential backoff.
+	retryBackoffInitialDuration = 100 * time.Millisecond
+	retryBackoffFactor          = 3
+	retryBackoffJitter          = 0
+	retryBackoffSteps           = 6
+)
+
+// Utility for retrying the given function with exponential backoff.
+func RetryWithExponentialBackOff(fn wait.ConditionFunc) error {
+	backoff := wait.Backoff{
+		Duration: retryBackoffInitialDuration,
+		Factor:   retryBackoffFactor,
+		Jitter:   retryBackoffJitter,
+		Steps:    retryBackoffSteps,
+	}
+	return wait.ExponentialBackoff(backoff, fn)
+}
+
+func IsRetryableAPIError(err error) bool {
+	// These errors may indicate a transient error that we can retry in tests.
+	if apierrs.IsInternalError(err) || apierrs.IsTimeout(err) || apierrs.IsServerTimeout(err) ||
+		apierrs.IsTooManyRequests(err) || utilnet.IsProbableEOF(err) || utilnet.IsConnectionReset(err) {
+		return true
+	}
+	// If the error sends the Retry-After header, we respect it as an explicit confirmation we should retry.
+	if _, shouldRetry := apierrs.SuggestsClientDelay(err); shouldRetry {
+		return true
+	}
+	return false
+}
+
+func CreatePodWithRetries(c clientset.Interface, namespace string, obj *v1.Pod) error {
+	if obj == nil {
+		return fmt.Errorf("Object provided to create is empty")
+	}
+	createFunc := func() (bool, error) {
+		_, err := c.CoreV1().Pods(namespace).Create(obj)
+		if err == nil || apierrs.IsAlreadyExists(err) {
+			return true, nil
+		}
+		if IsRetryableAPIError(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("Failed to create object with non-retriable error: %v", err)
+	}
+	return RetryWithExponentialBackOff(createFunc)
+}
+
+func CreateRCWithRetries(c clientset.Interface, namespace string, obj *v1.ReplicationController) error {
+	if obj == nil {
+		return fmt.Errorf("Object provided to create is empty")
+	}
+	createFunc := func() (bool, error) {
+		_, err := c.CoreV1().ReplicationControllers(namespace).Create(obj)
+		if err == nil || apierrs.IsAlreadyExists(err) {
+			return true, nil
+		}
+		if IsRetryableAPIError(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("Failed to create object with non-retriable error: %v", err)
+	}
+	return RetryWithExponentialBackOff(createFunc)
+}
+
+func CreateReplicaSetWithRetries(c clientset.Interface, namespace string, obj *apps.ReplicaSet) error {
+	if obj == nil {
+		return fmt.Errorf("Object provided to create is empty")
+	}
+	createFunc := func() (bool, error) {
+		_, err := c.AppsV1().ReplicaSets(namespace).Create(obj)
+		if err == nil || apierrs.IsAlreadyExists(err) {
+			return true, nil
+		}
+		if IsRetryableAPIError(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("Failed to create object with non-retriable error: %v", err)
+	}
+	return RetryWithExponentialBackOff(createFunc)
+}
+
+func CreateDeploymentWithRetries(c clientset.Interface, namespace string, obj *apps.Deployment) error {
+	if obj == nil {
+		return fmt.Errorf("Object provided to create is empty")
+	}
+	createFunc := func() (bool, error) {
+		_, err := c.AppsV1().Deployments(namespace).Create(obj)
+		if err == nil || apierrs.IsAlreadyExists(err) {
+			return true, nil
+		}
+		if IsRetryableAPIError(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("Failed to create object with non-retriable error: %v", err)
+	}
+	return RetryWithExponentialBackOff(createFunc)
+}
+
+func CreateDaemonSetWithRetries(c clientset.Interface, namespace string, obj *apps.DaemonSet) error {
+	if obj == nil {
+		return fmt.Errorf("Object provided to create is empty")
+	}
+	createFunc := func() (bool, error) {
+		_, err := c.AppsV1().DaemonSets(namespace).Create(obj)
+		if err == nil || apierrs.IsAlreadyExists(err) {
+			return true, nil
+		}
+		if IsRetryableAPIError(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("Failed to create object with non-retriable error: %v", err)
+	}
+	return RetryWithExponentialBackOff(createFunc)
+}
+
+func CreateJobWithRetries(c clientset.Interface, namespace string, obj *batch.Job) error {
+	if obj == nil {
+		return fmt.Errorf("Object provided to create is empty")
+	}
+	createFunc := func() (bool, error) {
+		_, err := c.BatchV1().Jobs(namespace).Create(obj)
+		if err == nil || apierrs.IsAlreadyExists(err) {
+			return true, nil
+		}
+		if IsRetryableAPIError(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("Failed to create object with non-retriable error: %v", err)
+	}
+	return RetryWithExponentialBackOff(createFunc)
+}
+
+func CreateSecretWithRetries(c clientset.Interface, namespace string, obj *v1.Secret) error {
+	if obj == nil {
+		return fmt.Errorf("Object provided to create is empty")
+	}
+	createFunc := func() (bool, error) {
+		_, err := c.CoreV1().Secrets(namespace).Create(obj)
+		if err == nil || apierrs.IsAlreadyExists(err) {
+			return true, nil
+		}
+		if IsRetryableAPIError(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("Failed to create object with non-retriable error: %v", err)
+	}
+	return RetryWithExponentialBackOff(createFunc)
+}
+
+func CreateConfigMapWithRetries(c clientset.Interface, namespace string, obj *v1.ConfigMap) error {
+	if obj == nil {
+		return fmt.Errorf("Object provided to create is empty")
+	}
+	createFunc := func() (bool, error) {
+		_, err := c.CoreV1().ConfigMaps(namespace).Create(obj)
+		if err == nil || apierrs.IsAlreadyExists(err) {
+			return true, nil
+		}
+		if IsRetryableAPIError(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("Failed to create object with non-retriable error: %v", err)
+	}
+	return RetryWithExponentialBackOff(createFunc)
+}
+
+func CreateServiceWithRetries(c clientset.Interface, namespace string, obj *v1.Service) error {
+	if obj == nil {
+		return fmt.Errorf("Object provided to create is empty")
+	}
+	createFunc := func() (bool, error) {
+		_, err := c.CoreV1().Services(namespace).Create(obj)
+		if err == nil || apierrs.IsAlreadyExists(err) {
+			return true, nil
+		}
+		if IsRetryableAPIError(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("Failed to create object with non-retriable error: %v", err)
+	}
+	return RetryWithExponentialBackOff(createFunc)
+}
+
+func CreateResourceQuotaWithRetries(c clientset.Interface, namespace string, obj *v1.ResourceQuota) error {
+	if obj == nil {
+		return fmt.Errorf("Object provided to create is empty")
+	}
+	createFunc := func() (bool, error) {
+		_, err := c.CoreV1().ResourceQuotas(namespace).Create(obj)
+		if err == nil || apierrs.IsAlreadyExists(err) {
+			return true, nil
+		}
+		if IsRetryableAPIError(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("Failed to create object with non-retriable error: %v", err)
+	}
+	return RetryWithExponentialBackOff(createFunc)
+}

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

@@ -0,0 +1,71 @@
+/*
+Copyright 2018 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.
+*/
+
+// TODO: Refactor common part of functions in this file for generic object kinds.
+
+package utils
+
+import (
+	"fmt"
+
+	apierrs "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	clientset "k8s.io/client-go/kubernetes"
+	appsinternal "k8s.io/kubernetes/pkg/apis/apps"
+	batchinternal "k8s.io/kubernetes/pkg/apis/batch"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	extensionsinternal "k8s.io/kubernetes/pkg/apis/extensions"
+)
+
+func deleteResource(c clientset.Interface, kind schema.GroupKind, namespace, name string, options *metav1.DeleteOptions) error {
+	switch kind {
+	case api.Kind("Pod"):
+		return c.CoreV1().Pods(namespace).Delete(name, options)
+	case api.Kind("ReplicationController"):
+		return c.CoreV1().ReplicationControllers(namespace).Delete(name, options)
+	case extensionsinternal.Kind("ReplicaSet"), appsinternal.Kind("ReplicaSet"):
+		return c.AppsV1().ReplicaSets(namespace).Delete(name, options)
+	case extensionsinternal.Kind("Deployment"), appsinternal.Kind("Deployment"):
+		return c.AppsV1().Deployments(namespace).Delete(name, options)
+	case extensionsinternal.Kind("DaemonSet"):
+		return c.AppsV1().DaemonSets(namespace).Delete(name, options)
+	case batchinternal.Kind("Job"):
+		return c.BatchV1().Jobs(namespace).Delete(name, options)
+	case api.Kind("Secret"):
+		return c.CoreV1().Secrets(namespace).Delete(name, options)
+	case api.Kind("ConfigMap"):
+		return c.CoreV1().ConfigMaps(namespace).Delete(name, options)
+	case api.Kind("Service"):
+		return c.CoreV1().Services(namespace).Delete(name, options)
+	default:
+		return fmt.Errorf("Unsupported kind when deleting: %v", kind)
+	}
+}
+
+func DeleteResourceWithRetries(c clientset.Interface, kind schema.GroupKind, namespace, name string, options *metav1.DeleteOptions) error {
+	deleteFunc := func() (bool, error) {
+		err := deleteResource(c, kind, namespace, name, options)
+		if err == nil || apierrs.IsNotFound(err) {
+			return true, nil
+		}
+		if IsRetryableAPIError(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("Failed to delete object with non-retriable error: %v", err)
+	}
+	return RetryWithExponentialBackOff(deleteFunc)
+}

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"
+
+	"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"
+	"k8s.io/klog"
+)
+
+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.CoreV1().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.CoreV1().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.CoreV1().Nodes().Update(node)
+		if err != nil {
+			if !apierrs.IsConflict(err) {
+				return err
+			} else {
+				klog.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.CoreV1().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,342 @@
+/*
+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"
+
+	apps "k8s.io/api/apps/v1"
+	"k8s.io/api/core/v1"
+	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 *apps.Deployment, allOldRSs []*apps.ReplicaSet, newRS *apps.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 *apps.Deployment, rsList []*apps.ReplicaSet, logf LogfFn) {
+	minReadySeconds := deployment.Spec.MinReadySeconds
+	podListFunc := func(namespace string, options metav1.ListOptions) (*v1.PodList, error) {
+		return c.CoreV1().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 to complete.
+// If during a rolling update (rolling == true), returns an error if the deployment's
+// rolling update strategy (max unavailable or max surge) is broken at any times.
+// It's not seen as a rolling update if shortly after a scaling event or the deployment is just created.
+func waitForDeploymentCompleteMaybeCheckRolling(c clientset.Interface, d *apps.Deployment, rolling bool, logf LogfFn, pollInterval, pollTimeout time.Duration) error {
+	var (
+		deployment *apps.Deployment
+		reason     string
+	)
+
+	err := wait.PollImmediate(pollInterval, pollTimeout, func() (bool, error) {
+		var err error
+		deployment, err = c.AppsV1().Deployments(d.Namespace).Get(d.Name, metav1.GetOptions{})
+		if err != nil {
+			return false, err
+		}
+
+		// If during a rolling update, make sure rolling update strategy isn't broken at any times.
+		if rolling {
+			reason, err = checkRollingUpdateStatus(c, deployment, logf)
+			if err != nil {
+				return false, err
+			}
+			logf(reason)
+		}
+
+		// When the deployment status and its underlying resources reach the desired state, we're done
+		if deploymentutil.DeploymentComplete(d, &deployment.Status) {
+			return true, nil
+		}
+
+		reason = fmt.Sprintf("deployment status: %#v", deployment.Status)
+		logf(reason)
+
+		return false, nil
+	})
+
+	if err == wait.ErrWaitTimeout {
+		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
+}
+
+func checkRollingUpdateStatus(c clientset.Interface, deployment *apps.Deployment, logf LogfFn) (string, error) {
+	var reason string
+	oldRSs, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(deployment, c.AppsV1())
+	if err != nil {
+		return "", err
+	}
+	if newRS == nil {
+		// New RC hasn't been created yet.
+		reason = "new replica set hasn't been created yet"
+		return reason, 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, apps.DefaultDeploymentUniqueLabelKey) {
+			reason = "all replica sets need to contain the pod-template-hash label"
+			return reason, nil
+		}
+	}
+
+	// Check max surge and min available
+	totalCreated := deploymentutil.GetReplicaCountForReplicaSets(allRSs)
+	maxCreated := *(deployment.Spec.Replicas) + deploymentutil.MaxSurge(*deployment)
+	if totalCreated > maxCreated {
+		LogReplicaSetsOfDeployment(deployment, allOldRSs, newRS, logf)
+		LogPodsOfDeployment(c, deployment, allRSs, logf)
+		return "", fmt.Errorf("total pods created: %d, more than the max allowed: %d", totalCreated, maxCreated)
+	}
+	minAvailable := deploymentutil.MinAvailable(deployment)
+	if deployment.Status.AvailableReplicas < minAvailable {
+		LogReplicaSetsOfDeployment(deployment, allOldRSs, newRS, logf)
+		LogPodsOfDeployment(c, deployment, allRSs, logf)
+		return "", fmt.Errorf("total pods available: %d, less than the min required: %d", deployment.Status.AvailableReplicas, minAvailable)
+	}
+	return "", nil
+}
+
+// Waits for the deployment to complete, and check rolling update strategy isn't broken at any times.
+// Rolling update strategy should not be broken during a rolling update.
+func WaitForDeploymentCompleteAndCheckRolling(c clientset.Interface, d *apps.Deployment, logf LogfFn, pollInterval, pollTimeout time.Duration) error {
+	rolling := true
+	return waitForDeploymentCompleteMaybeCheckRolling(c, d, rolling, logf, pollInterval, pollTimeout)
+}
+
+// Waits for the deployment to complete, and don't check if rolling update strategy is broken.
+// Rolling update strategy is used only during a rolling update, and can be violated in other situations,
+// such as shortly after a scaling event or the deployment is just created.
+func WaitForDeploymentComplete(c clientset.Interface, d *apps.Deployment, logf LogfFn, pollInterval, pollTimeout time.Duration) error {
+	rolling := false
+	return waitForDeploymentCompleteMaybeCheckRolling(c, d, rolling, logf, pollInterval, pollTimeout)
+}
+
+// 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 *apps.Deployment
+	var newRS *apps.ReplicaSet
+	var reason string
+	err := wait.PollImmediate(pollInterval, pollTimeout, func() (bool, error) {
+		var err error
+		deployment, err = c.AppsV1().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.AppsV1())
+		if err != nil {
+			return false, err
+		}
+		if err := checkRevisionAndImage(deployment, newRS, revision, image); err != nil {
+			reason = err.Error()
+			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
+}
+
+// CheckDeploymentRevisionAndImage checks if the input deployment's and its new replica set's revision and image are as expected.
+func CheckDeploymentRevisionAndImage(c clientset.Interface, ns, deploymentName, revision, image string) error {
+	deployment, err := c.AppsV1().Deployments(ns).Get(deploymentName, metav1.GetOptions{})
+	if err != nil {
+		return fmt.Errorf("unable to get deployment %s during revision check: %v", deploymentName, err)
+	}
+
+	// Check revision of the new replica set of this deployment
+	newRS, err := deploymentutil.GetNewReplicaSet(deployment, c.AppsV1())
+	if err != nil {
+		return fmt.Errorf("unable to get new replicaset of deployment %s during revision check: %v", deploymentName, err)
+	}
+	return checkRevisionAndImage(deployment, newRS, revision, image)
+}
+
+func checkRevisionAndImage(deployment *apps.Deployment, newRS *apps.ReplicaSet, revision, image string) error {
+	// The new ReplicaSet needs to be non-nil and contain the pod-template-hash label
+	if newRS == nil {
+		return fmt.Errorf("new replicaset for deployment %q is yet to be created", deployment.Name)
+	}
+	if !labelsutil.SelectorHasLabel(newRS.Spec.Selector, apps.DefaultDeploymentUniqueLabelKey) {
+		return fmt.Errorf("new replica set %q doesn't have %q label selector", newRS.Name, apps.DefaultDeploymentUniqueLabelKey)
+	}
+	// Check revision of this deployment, and of the new replica set of this deployment
+	if deployment.Annotations == nil || deployment.Annotations[deploymentutil.RevisionAnnotation] != revision {
+		return fmt.Errorf("deployment %q doesn't have the required revision set", deployment.Name)
+	}
+	if newRS.Annotations == nil || newRS.Annotations[deploymentutil.RevisionAnnotation] != revision {
+		return fmt.Errorf("new replicaset %q doesn't have the required revision set", newRS.Name)
+	}
+	// Check the image of this deployment, and of the new replica set of this deployment
+	if !containsImage(deployment.Spec.Template.Spec.Containers, image) {
+		return fmt.Errorf("deployment %q doesn't have the required image %s set", deployment.Name, image)
+	}
+	if !containsImage(newRS.Spec.Template.Spec.Containers, image) {
+		return fmt.Errorf("new replica set %q doesn't have the required image %s.", newRS.Name, image)
+	}
+	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 *apps.Deployment)
+
+func UpdateDeploymentWithRetries(c clientset.Interface, namespace, name string, applyUpdate UpdateDeploymentFunc, logf LogfFn, pollInterval, pollTimeout time.Duration) (*apps.Deployment, error) {
+	var deployment *apps.Deployment
+	var updateErr error
+	pollErr := wait.PollImmediate(pollInterval, pollTimeout, func() (bool, error) {
+		var err error
+		if deployment, err = c.AppsV1().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.AppsV1().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() (*apps.Deployment, error) {
+		return c.AppsV1().Deployments(ns).Get(deploymentName, metav1.GetOptions{})
+	}, desiredGeneration, 2*time.Second, 1*time.Minute)
+}
+
+// WaitForDeploymentRollbackCleared waits for given deployment either started rolling back or doesn't need to rollback.
+func WaitForDeploymentRollbackCleared(c clientset.Interface, ns, deploymentName string, pollInterval, pollTimeout time.Duration) error {
+	err := wait.PollImmediate(pollInterval, pollTimeout, func() (bool, error) {
+		deployment, err := c.AppsV1().Deployments(ns).Get(deploymentName, metav1.GetOptions{})
+		if err != nil {
+			return false, err
+		}
+		// Rollback not set or is kicked off
+		if deployment.Annotations[apps.DeprecatedRollbackTo] == "" {
+			return true, nil
+		}
+		return false, nil
+	})
+	if err != nil {
+		return fmt.Errorf("error waiting for deployment %s rollbackTo to be cleared: %v", deploymentName, err)
+	}
+	return nil
+}
+
+// WaitForDeploymentUpdatedReplicasGTE waits for given deployment to be observed by the controller and has at least a number of updatedReplicas
+func WaitForDeploymentUpdatedReplicasGTE(c clientset.Interface, ns, deploymentName string, minUpdatedReplicas int32, desiredGeneration int64, pollInterval, pollTimeout time.Duration) error {
+	var deployment *apps.Deployment
+	err := wait.PollImmediate(pollInterval, pollTimeout, func() (bool, error) {
+		d, err := c.AppsV1().Deployments(ns).Get(deploymentName, metav1.GetOptions{})
+		if err != nil {
+			return false, err
+		}
+		deployment = d
+		return deployment.Status.ObservedGeneration >= desiredGeneration && deployment.Status.UpdatedReplicas >= minUpdatedReplicas, nil
+	})
+	if err != nil {
+		return fmt.Errorf("error waiting for deployment %q to have at least %d updatedReplicas: %v; latest .status.updatedReplicas: %d", deploymentName, minUpdatedReplicas, err, deployment.Status.UpdatedReplicas)
+	}
+	return nil
+}
+
+func WaitForDeploymentWithCondition(c clientset.Interface, ns, deploymentName, reason string, condType apps.DeploymentConditionType, logf LogfFn, pollInterval, pollTimeout time.Duration) error {
+	var deployment *apps.Deployment
+	pollErr := wait.PollImmediate(pollInterval, pollTimeout, func() (bool, error) {
+		d, err := c.AppsV1().Deployments(ns).Get(deploymentName, metav1.GetOptions{})
+		if err != nil {
+			return false, err
+		}
+		deployment = d
+		cond := deploymentutil.GetDeploymentCondition(deployment.Status, condType)
+		return cond != nil && cond.Reason == reason, nil
+	})
+	if pollErr == wait.ErrWaitTimeout {
+		pollErr = fmt.Errorf("deployment %q never updated with the desired condition and reason, latest deployment conditions: %+v", deployment.Name, deployment.Status.Conditions)
+		_, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(deployment, c.AppsV1())
+		if err == nil {
+			LogReplicaSetsOfDeployment(deployment, allOldRSs, newRS, logf)
+			LogPodsOfDeployment(c, deployment, append(allOldRSs, newRS), logf)
+		}
+	}
+	return pollErr
+}

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

@@ -0,0 +1,270 @@
+/*
+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"
+	"io/ioutil"
+	"os"
+
+	yaml "gopkg.in/yaml.v2"
+)
+
+// RegistryList holds public and private image registries
+type RegistryList struct {
+	DockerLibraryRegistry string `yaml:"dockerLibraryRegistry"`
+	E2eRegistry           string `yaml:"e2eRegistry"`
+	EtcdRegistry          string `yaml:"etcdRegistry"`
+	GcRegistry            string `yaml:"gcRegistry"`
+	PrivateRegistry       string `yaml:"privateRegistry"`
+	SampleRegistry        string `yaml:"sampleRegistry"`
+}
+
+// Config holds an images registry, name, and version
+type Config struct {
+	registry string
+	name     string
+	version  string
+}
+
+// SetRegistry sets an image registry in a Config struct
+func (i *Config) SetRegistry(registry string) {
+	i.registry = registry
+}
+
+// SetName sets an image name in a Config struct
+func (i *Config) SetName(name string) {
+	i.name = name
+}
+
+// SetVersion sets an image version in a Config struct
+func (i *Config) SetVersion(version string) {
+	i.version = version
+}
+
+func initReg() RegistryList {
+	registry := RegistryList{
+		DockerLibraryRegistry: "docker.io/library",
+		E2eRegistry:           "gcr.io/kubernetes-e2e-test-images",
+		EtcdRegistry:          "quay.io/coreos",
+		GcRegistry:            "k8s.gcr.io",
+		PrivateRegistry:       "gcr.io/k8s-authenticated-test",
+		SampleRegistry:        "gcr.io/google-samples",
+	}
+	repoList := os.Getenv("KUBE_TEST_REPO_LIST")
+	if repoList == "" {
+		return registry
+	}
+
+	fileContent, err := ioutil.ReadFile(repoList)
+	if err != nil {
+		panic(fmt.Errorf("Error reading '%v' file contents: %v", repoList, err))
+	}
+
+	err = yaml.Unmarshal(fileContent, &registry)
+	if err != nil {
+		panic(fmt.Errorf("Error unmarshalling '%v' YAML file: %v", repoList, err))
+	}
+	return registry
+}
+
+var (
+	registry              = initReg()
+	dockerLibraryRegistry = registry.DockerLibraryRegistry
+	e2eRegistry           = registry.E2eRegistry
+	etcdRegistry          = registry.EtcdRegistry
+	gcRegistry            = registry.GcRegistry
+	// PrivateRegistry is an image repository that requires authentication
+	PrivateRegistry = registry.PrivateRegistry
+	sampleRegistry  = registry.SampleRegistry
+
+	// Preconfigured image configs
+	imageConfigs = initImageConfigs()
+)
+
+const (
+	// CRDConversionWebhook image
+	CRDConversionWebhook = iota
+	// AdmissionWebhook image
+	AdmissionWebhook
+	// APIServer image
+	APIServer
+	// AppArmorLoader image
+	AppArmorLoader
+	// AuditProxy image
+	AuditProxy
+	// BusyBox image
+	BusyBox
+	// CheckMetadataConcealment image
+	CheckMetadataConcealment
+	// CudaVectorAdd image
+	CudaVectorAdd
+	// CudaVectorAdd2 image
+	CudaVectorAdd2
+	// Dnsutils image
+	Dnsutils
+	// EchoServer image
+	EchoServer
+	// EntrypointTester image
+	EntrypointTester
+	// Etcd image
+	Etcd
+	// Fakegitserver image
+	Fakegitserver
+	// GBFrontend image
+	GBFrontend
+	// GBRedisSlave image
+	GBRedisSlave
+	// Hostexec image
+	Hostexec
+	// IpcUtils image
+	IpcUtils
+	// Iperf image
+	Iperf
+	// JessieDnsutils image
+	JessieDnsutils
+	// Kitten image
+	Kitten
+	// Liveness image
+	Liveness
+	// LogsGenerator image
+	LogsGenerator
+	// Mounttest image
+	Mounttest
+	// MounttestUser image
+	MounttestUser
+	// Nautilus image
+	Nautilus
+	// Net image
+	Net
+	// Netexec image
+	Netexec
+	// Nettest image
+	Nettest
+	// Nginx image
+	Nginx
+	// NginxNew image
+	NginxNew
+	// Nonewprivs image
+	Nonewprivs
+	// NoSnatTest image
+	NoSnatTest
+	// NoSnatTestProxy image
+	NoSnatTestProxy
+	// Pause - when these values are updated, also update cmd/kubelet/app/options/container_runtime.go
+	// Pause image
+	Pause
+	// Porter image
+	Porter
+	// PortForwardTester image
+	PortForwardTester
+	// Redis image
+	Redis
+	// ResourceConsumer image
+	ResourceConsumer
+	// ResourceController image
+	ResourceController
+	// ServeHostname image
+	ServeHostname
+	// TestWebserver image
+	TestWebserver
+	// VolumeNFSServer image
+	VolumeNFSServer
+	// VolumeISCSIServer image
+	VolumeISCSIServer
+	// VolumeGlusterServer image
+	VolumeGlusterServer
+	// VolumeRBDServer image
+	VolumeRBDServer
+)
+
+func initImageConfigs() map[int]Config {
+	configs := map[int]Config{}
+	configs[CRDConversionWebhook] = Config{e2eRegistry, "crd-conversion-webhook", "1.13rev2"}
+	configs[AdmissionWebhook] = Config{e2eRegistry, "webhook", "1.14v1"}
+	configs[APIServer] = Config{e2eRegistry, "sample-apiserver", "1.10"}
+	configs[AppArmorLoader] = Config{e2eRegistry, "apparmor-loader", "1.0"}
+	configs[AuditProxy] = Config{e2eRegistry, "audit-proxy", "1.0"}
+	configs[BusyBox] = Config{dockerLibraryRegistry, "busybox", "1.29"}
+	configs[CheckMetadataConcealment] = Config{e2eRegistry, "metadata-concealment", "1.2"}
+	configs[CudaVectorAdd] = Config{e2eRegistry, "cuda-vector-add", "1.0"}
+	configs[CudaVectorAdd2] = Config{e2eRegistry, "cuda-vector-add", "2.0"}
+	configs[Dnsutils] = Config{e2eRegistry, "dnsutils", "1.1"}
+	configs[EchoServer] = Config{e2eRegistry, "echoserver", "2.2"}
+	configs[EntrypointTester] = Config{e2eRegistry, "entrypoint-tester", "1.0"}
+	configs[Etcd] = Config{etcdRegistry, "etcd", "v3.3.10"}
+	configs[Fakegitserver] = Config{e2eRegistry, "fakegitserver", "1.0"}
+	configs[GBFrontend] = Config{sampleRegistry, "gb-frontend", "v6"}
+	configs[GBRedisSlave] = Config{sampleRegistry, "gb-redisslave", "v3"}
+	configs[Hostexec] = Config{e2eRegistry, "hostexec", "1.1"}
+	configs[IpcUtils] = Config{e2eRegistry, "ipc-utils", "1.0"}
+	configs[Iperf] = Config{e2eRegistry, "iperf", "1.0"}
+	configs[JessieDnsutils] = Config{e2eRegistry, "jessie-dnsutils", "1.0"}
+	configs[Kitten] = Config{e2eRegistry, "kitten", "1.0"}
+	configs[Liveness] = Config{e2eRegistry, "liveness", "1.1"}
+	configs[LogsGenerator] = Config{e2eRegistry, "logs-generator", "1.0"}
+	configs[Mounttest] = Config{e2eRegistry, "mounttest", "1.0"}
+	configs[MounttestUser] = Config{e2eRegistry, "mounttest-user", "1.0"}
+	configs[Nautilus] = Config{e2eRegistry, "nautilus", "1.0"}
+	configs[Net] = Config{e2eRegistry, "net", "1.0"}
+	configs[Netexec] = Config{e2eRegistry, "netexec", "1.1"}
+	configs[Nettest] = Config{e2eRegistry, "nettest", "1.0"}
+	configs[Nginx] = Config{dockerLibraryRegistry, "nginx", "1.14-alpine"}
+	configs[NginxNew] = Config{dockerLibraryRegistry, "nginx", "1.15-alpine"}
+	configs[Nonewprivs] = Config{e2eRegistry, "nonewprivs", "1.0"}
+	configs[NoSnatTest] = Config{e2eRegistry, "no-snat-test", "1.0"}
+	configs[NoSnatTestProxy] = Config{e2eRegistry, "no-snat-test-proxy", "1.0"}
+	// Pause - when these values are updated, also update cmd/kubelet/app/options/container_runtime.go
+	configs[Pause] = Config{gcRegistry, "pause", "3.1"}
+	configs[Porter] = Config{e2eRegistry, "porter", "1.0"}
+	configs[PortForwardTester] = Config{e2eRegistry, "port-forward-tester", "1.0"}
+	configs[Redis] = Config{e2eRegistry, "redis", "1.0"}
+	configs[ResourceConsumer] = Config{e2eRegistry, "resource-consumer", "1.5"}
+	configs[ResourceController] = Config{e2eRegistry, "resource-consumer/controller", "1.0"}
+	configs[ServeHostname] = Config{e2eRegistry, "serve-hostname", "1.1"}
+	configs[TestWebserver] = Config{e2eRegistry, "test-webserver", "1.0"}
+	configs[VolumeNFSServer] = Config{e2eRegistry, "volume/nfs", "1.0"}
+	configs[VolumeISCSIServer] = Config{e2eRegistry, "volume/iscsi", "1.0"}
+	configs[VolumeGlusterServer] = Config{e2eRegistry, "volume/gluster", "1.0"}
+	configs[VolumeRBDServer] = Config{e2eRegistry, "volume/rbd", "1.0.1"}
+	return configs
+}
+
+// GetImageConfigs returns the map of imageConfigs
+func GetImageConfigs() map[int]Config {
+	return imageConfigs
+}
+
+// GetConfig returns the Config object for an image
+func GetConfig(image int) Config {
+	return imageConfigs[image]
+}
+
+// GetE2EImage returns the fully qualified URI to an image (including version)
+func GetE2EImage(image int) string {
+	return fmt.Sprintf("%s/%s:%s", imageConfigs[image].registry, imageConfigs[image].name, imageConfigs[image].version)
+}
+
+// GetE2EImage returns the fully qualified URI to an image (including version)
+func (i *Config) GetE2EImage() string {
+	return fmt.Sprintf("%s/%s:%s", i.registry, i.name, i.version)
+}
+
+// GetPauseImageName returns the pause image name with proper version
+func GetPauseImageName() string {
+	return GetE2EImage(Pause)
+}

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

@@ -0,0 +1,33 @@
+/*
+Copyright 2018 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"
+
+// GetNodeCondition extracts the provided condition from the given status and returns that.
+// Returns nil and -1 if the condition is not present, and the index of the located condition.
+func GetNodeCondition(status *v1.NodeStatus, conditionType v1.NodeConditionType) (int, *v1.NodeCondition) {
+	if status == nil {
+		return -1, nil
+	}
+	for i := range status.Conditions {
+		if status.Conditions[i].Type == conditionType {
+			return i, &status.Conditions[i]
+		}
+	}
+	return -1, nil
+}

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

@@ -0,0 +1,72 @@
+/*
+Copyright 2018 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 (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+)
+
+// GetK8sRootDir returns the root directory for kubernetes, if present in the gopath.
+func GetK8sRootDir() (string, error) {
+	dir, err := RootDir()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(dir, fmt.Sprintf("%s/", "k8s.io/kubernetes")), nil
+}
+
+// GetCAdvisorRootDir returns the root directory for cAdvisor, if present in the gopath.
+func GetCAdvisorRootDir() (string, error) {
+	dir, err := RootDir()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(dir, fmt.Sprintf("%s/", "github.com/google/cadvisor")), nil
+}
+
+// RootDir gets the on-disk kubernetes source directory, returning an error is none is found
+func RootDir() (string, error) {
+	// Get the directory of the current executable
+	_, testExec, _, _ := runtime.Caller(0)
+	path := filepath.Dir(testExec)
+
+	// Look for the kubernetes source root directory
+	if strings.Contains(path, "k8s.io/kubernetes") {
+		splitPath := strings.Split(path, "k8s.io/kubernetes")
+		return splitPath[0], nil
+	}
+
+	return "", errors.New("could not find kubernetes source root directory")
+}
+
+// GetK8sBuildOutputDir returns the build output directory for k8s
+func GetK8sBuildOutputDir() (string, error) {
+	k8sRoot, err := GetK8sRootDir()
+	if err != nil {
+		return "", err
+	}
+	buildOutputDir := filepath.Join(k8sRoot, "_output/local/go/bin")
+	if _, err := os.Stat(buildOutputDir); err != nil {
+		return "", err
+	}
+	return buildOutputDir, nil
+}

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

@@ -0,0 +1,80 @@
+/*
+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 (
+	"time"
+
+	"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/util/wait"
+	"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, error) {
+	lw := &cache.ListWatch{
+		ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
+			options.LabelSelector = label.String()
+			options.FieldSelector = field.String()
+			obj, err := c.CoreV1().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.CoreV1().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)
+	if err := wait.PollImmediate(50*time.Millisecond, 2*time.Minute, func() (bool, error) {
+		if len(reflector.LastSyncResourceVersion()) != 0 {
+			return true, nil
+		}
+		return false, nil
+	}); err != nil {
+		return nil, err
+	}
+	return &PodStore{Store: store, stopCh: stopCh, Reflector: reflector}, nil
+}
+
+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/replicaset.go

@@ -0,0 +1,91 @@
+/*
+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 utils
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	apps "k8s.io/api/apps/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/wait"
+	clientset "k8s.io/client-go/kubernetes"
+)
+
+type UpdateReplicaSetFunc func(d *apps.ReplicaSet)
+
+func UpdateReplicaSetWithRetries(c clientset.Interface, namespace, name string, applyUpdate UpdateReplicaSetFunc, logf LogfFn, pollInterval, pollTimeout time.Duration) (*apps.ReplicaSet, error) {
+	var rs *apps.ReplicaSet
+	var updateErr error
+	pollErr := wait.PollImmediate(pollInterval, pollTimeout, func() (bool, error) {
+		var err error
+		if rs, err = c.AppsV1().ReplicaSets(namespace).Get(name, metav1.GetOptions{}); err != nil {
+			return false, err
+		}
+		// Apply the update, then attempt to push it to the apiserver.
+		applyUpdate(rs)
+		if rs, err = c.AppsV1().ReplicaSets(namespace).Update(rs); err == nil {
+			logf("Updating replica set %q", name)
+			return true, nil
+		}
+		updateErr = err
+		return false, nil
+	})
+	if pollErr == wait.ErrWaitTimeout {
+		pollErr = fmt.Errorf("couldn't apply the provided updated to replicaset %q: %v", name, updateErr)
+	}
+	return rs, pollErr
+}
+
+// Verify .Status.Replicas is equal to .Spec.Replicas
+func WaitRSStable(t *testing.T, clientSet clientset.Interface, rs *apps.ReplicaSet, pollInterval, pollTimeout time.Duration) error {
+	desiredGeneration := rs.Generation
+	if err := wait.PollImmediate(pollInterval, pollTimeout, func() (bool, error) {
+		newRS, err := clientSet.AppsV1().ReplicaSets(rs.Namespace).Get(rs.Name, metav1.GetOptions{})
+		if err != nil {
+			return false, err
+		}
+		return newRS.Status.ObservedGeneration >= desiredGeneration && newRS.Status.Replicas == *rs.Spec.Replicas, nil
+	}); err != nil {
+		return fmt.Errorf("failed to verify .Status.Replicas is equal to .Spec.Replicas for replicaset %q: %v", rs.Name, err)
+	}
+	return nil
+}
+
+func UpdateReplicaSetStatusWithRetries(c clientset.Interface, namespace, name string, applyUpdate UpdateReplicaSetFunc, logf LogfFn, pollInterval, pollTimeout time.Duration) (*apps.ReplicaSet, error) {
+	var rs *apps.ReplicaSet
+	var updateErr error
+	pollErr := wait.PollImmediate(pollInterval, pollTimeout, func() (bool, error) {
+		var err error
+		if rs, err = c.AppsV1().ReplicaSets(namespace).Get(name, metav1.GetOptions{}); err != nil {
+			return false, err
+		}
+		// Apply the update, then attempt to push it to the apiserver.
+		applyUpdate(rs)
+		if rs, err = c.AppsV1().ReplicaSets(namespace).UpdateStatus(rs); err == nil {
+			logf("Updating replica set %q", name)
+			return true, nil
+		}
+		updateErr = err
+		return false, nil
+	})
+	if pollErr == wait.ErrWaitTimeout {
+		pollErr = fmt.Errorf("couldn't apply the provided update to replicaset %q: %v", name, updateErr)
+	}
+	return rs, pollErr
+}

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

@@ -0,0 +1,34 @@
+/*
+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"
+
+	"k8s.io/klog"
+)
+
+func MakeTempDirOrDie(prefix string, baseDir string) string {
+	if baseDir == "" {
+		baseDir = "/tmp"
+	}
+	tempDir, err := ioutil.TempDir(baseDir, prefix)
+	if err != nil {
+		klog.Fatalf("Can't make a temp rootdir: %v", err)
+	}
+	return tempDir
+}

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

@@ -0,0 +1,64 @@
+/*
+Copyright 2018 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"
+
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/client-go/scale"
+	"k8s.io/kubernetes/pkg/kubectl"
+)
+
+const (
+	// Parameters for retrying updates/waits with linear backoff.
+	// TODO: Try to move this to exponential backoff by modifying kubectl.Scale().
+	updateRetryInterval = 5 * time.Second
+	updateRetryTimeout  = 1 * time.Minute
+	waitRetryInterval   = 5 * time.Second
+	waitRetryTimeout    = 5 * time.Minute
+)
+
+func RetryErrorCondition(condition wait.ConditionFunc) wait.ConditionFunc {
+	return func() (bool, error) {
+		done, err := condition()
+		if err != nil && IsRetryableAPIError(err) {
+			return false, nil
+		}
+		return done, err
+	}
+}
+
+func ScaleResourceWithRetries(scalesGetter scale.ScalesGetter, namespace, name string, size uint, gr schema.GroupResource) error {
+	scaler := kubectl.NewScaler(scalesGetter)
+	preconditions := &kubectl.ScalePrecondition{
+		Size:            -1,
+		ResourceVersion: "",
+	}
+	waitForReplicas := kubectl.NewRetryParams(waitRetryInterval, waitRetryTimeout)
+	cond := RetryErrorCondition(kubectl.ScaleCondition(scaler, preconditions, namespace, name, size, nil, gr))
+	err := wait.PollImmediate(updateRetryInterval, updateRetryTimeout, cond)
+	if err == nil {
+		err = kubectl.WaitForScaleHasDesiredReplicas(scalesGetter, gr, name, namespace, size, waitForReplicas)
+	}
+	if err != nil {
+		return fmt.Errorf("Error while scaling %s to %d replicas: %v", name, size, err)
+	}
+	return nil
+}