vendor files

vendor/k8s.io/kubernetes/pkg/controller/replication/BUILD

@@ -0,0 +1,66 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "conversion.go",
+        "doc.go",
+        "replication_controller.go",
+        "replication_controller_utils.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/controller/replication",
+    deps = [
+        "//pkg/apis/core/v1:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/apis/extensions/v1beta1:go_default_library",
+        "//pkg/controller:go_default_library",
+        "//pkg/controller/replicaset:go_default_library",
+        "//vendor/github.com/golang/glog: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/apis/meta/v1: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/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/client-go/informers/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/scheme:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/typed/apps/v1:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/typed/apps/v1beta2:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/typed/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/typed/extensions/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/listers/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/listers/extensions/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+        "//vendor/k8s.io/client-go/tools/record:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["replication_controller_utils_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/controller/replication",
+    library = ":go_default_library",
+    deps = ["//vendor/k8s.io/api/core/v1:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/controller/replication/OWNERS

@@ -0,0 +1,9 @@
+approvers:
+- caesarxuchao
+- lavalamp
+- enisoc
+reviewers:
+- caesarxuchao
+- lavalamp
+- tnozicka
+- enisoc

vendor/k8s.io/kubernetes/pkg/controller/replication/conversion.go

@@ -0,0 +1,372 @@
+/*
+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.
+*/
+
+// This file contains adapters that convert between RC and RS,
+// as if ReplicationController were an older API version of ReplicaSet.
+// It allows ReplicaSetController to directly replace the old ReplicationManager,
+// which was previously a manually-maintained copy-paste of RSC.
+
+package replication
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	"k8s.io/api/core/v1"
+	extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/types"
+	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
+	"k8s.io/apimachinery/pkg/watch"
+	coreinformers "k8s.io/client-go/informers/core/v1"
+	clientset "k8s.io/client-go/kubernetes"
+	appsv1 "k8s.io/client-go/kubernetes/typed/apps/v1"
+	appsv1beta2 "k8s.io/client-go/kubernetes/typed/apps/v1beta2"
+	v1client "k8s.io/client-go/kubernetes/typed/core/v1"
+	extensionsv1beta1client "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
+	v1listers "k8s.io/client-go/listers/core/v1"
+	extensionslisters "k8s.io/client-go/listers/extensions/v1beta1"
+	"k8s.io/client-go/tools/cache"
+	apiv1 "k8s.io/kubernetes/pkg/apis/core/v1"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	extensionsinternalv1beta1 "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
+	"k8s.io/kubernetes/pkg/controller"
+)
+
+// informerAdapter implements ReplicaSetInformer by wrapping ReplicationControllerInformer
+// and converting objects.
+type informerAdapter struct {
+	rcInformer coreinformers.ReplicationControllerInformer
+}
+
+func (i informerAdapter) Informer() cache.SharedIndexInformer {
+	return conversionInformer{i.rcInformer.Informer()}
+}
+
+func (i informerAdapter) Lister() extensionslisters.ReplicaSetLister {
+	return conversionLister{i.rcInformer.Lister()}
+}
+
+type conversionInformer struct {
+	cache.SharedIndexInformer
+}
+
+func (i conversionInformer) AddEventHandler(handler cache.ResourceEventHandler) {
+	i.SharedIndexInformer.AddEventHandler(conversionEventHandler{handler})
+}
+
+func (i conversionInformer) AddEventHandlerWithResyncPeriod(handler cache.ResourceEventHandler, resyncPeriod time.Duration) {
+	i.SharedIndexInformer.AddEventHandlerWithResyncPeriod(conversionEventHandler{handler}, resyncPeriod)
+}
+
+type conversionLister struct {
+	rcLister v1listers.ReplicationControllerLister
+}
+
+func (l conversionLister) List(selector labels.Selector) ([]*extensionsv1beta1.ReplicaSet, error) {
+	rcList, err := l.rcLister.List(selector)
+	if err != nil {
+		return nil, err
+	}
+	return convertSlice(rcList)
+}
+
+func (l conversionLister) ReplicaSets(namespace string) extensionslisters.ReplicaSetNamespaceLister {
+	return conversionNamespaceLister{l.rcLister.ReplicationControllers(namespace)}
+}
+
+func (l conversionLister) GetPodReplicaSets(pod *v1.Pod) ([]*extensionsv1beta1.ReplicaSet, error) {
+	rcList, err := l.rcLister.GetPodControllers(pod)
+	if err != nil {
+		return nil, err
+	}
+	return convertSlice(rcList)
+}
+
+type conversionNamespaceLister struct {
+	rcLister v1listers.ReplicationControllerNamespaceLister
+}
+
+func (l conversionNamespaceLister) List(selector labels.Selector) ([]*extensionsv1beta1.ReplicaSet, error) {
+	rcList, err := l.rcLister.List(selector)
+	if err != nil {
+		return nil, err
+	}
+	return convertSlice(rcList)
+}
+
+func (l conversionNamespaceLister) Get(name string) (*extensionsv1beta1.ReplicaSet, error) {
+	rc, err := l.rcLister.Get(name)
+	if err != nil {
+		return nil, err
+	}
+	return convertRCtoRS(rc, nil)
+}
+
+type conversionEventHandler struct {
+	handler cache.ResourceEventHandler
+}
+
+func (h conversionEventHandler) OnAdd(obj interface{}) {
+	rs, err := convertRCtoRS(obj.(*v1.ReplicationController), nil)
+	if err != nil {
+		utilruntime.HandleError(fmt.Errorf("dropping RC OnAdd event: can't convert object %#v to RS: %v", obj, err))
+		return
+	}
+	h.handler.OnAdd(rs)
+}
+
+func (h conversionEventHandler) OnUpdate(oldObj, newObj interface{}) {
+	oldRS, err := convertRCtoRS(oldObj.(*v1.ReplicationController), nil)
+	if err != nil {
+		utilruntime.HandleError(fmt.Errorf("dropping RC OnUpdate event: can't convert old object %#v to RS: %v", oldObj, err))
+		return
+	}
+	newRS, err := convertRCtoRS(newObj.(*v1.ReplicationController), nil)
+	if err != nil {
+		utilruntime.HandleError(fmt.Errorf("dropping RC OnUpdate event: can't convert new object %#v to RS: %v", newObj, err))
+		return
+	}
+	h.handler.OnUpdate(oldRS, newRS)
+}
+
+func (h conversionEventHandler) OnDelete(obj interface{}) {
+	rc, ok := obj.(*v1.ReplicationController)
+	if !ok {
+		// Convert the Obj inside DeletedFinalStateUnknown.
+		tombstone, ok := obj.(cache.DeletedFinalStateUnknown)
+		if !ok {
+			utilruntime.HandleError(fmt.Errorf("dropping RC OnDelete event: couldn't get object from tombstone %+v", obj))
+			return
+		}
+		rc, ok = tombstone.Obj.(*v1.ReplicationController)
+		if !ok {
+			utilruntime.HandleError(fmt.Errorf("dropping RC OnDelete event: tombstone contained object that is not a RC %#v", obj))
+			return
+		}
+		rs, err := convertRCtoRS(rc, nil)
+		if err != nil {
+			utilruntime.HandleError(fmt.Errorf("dropping RC OnDelete event: can't convert object %#v to RS: %v", obj, err))
+			return
+		}
+		h.handler.OnDelete(cache.DeletedFinalStateUnknown{Key: tombstone.Key, Obj: rs})
+		return
+	}
+
+	// It's a regular RC object.
+	rs, err := convertRCtoRS(rc, nil)
+	if err != nil {
+		utilruntime.HandleError(fmt.Errorf("dropping RC OnDelete event: can't convert object %#v to RS: %v", obj, err))
+		return
+	}
+	h.handler.OnDelete(rs)
+}
+
+type clientsetAdapter struct {
+	clientset.Interface
+}
+
+func (c clientsetAdapter) ExtensionsV1beta1() extensionsv1beta1client.ExtensionsV1beta1Interface {
+	return conversionExtensionsClient{c.Interface, c.Interface.ExtensionsV1beta1()}
+}
+
+func (c clientsetAdapter) Extensions() extensionsv1beta1client.ExtensionsV1beta1Interface {
+	return conversionExtensionsClient{c.Interface, c.Interface.Extensions()}
+}
+
+func (c clientsetAdapter) AppsV1beta2() appsv1beta2.AppsV1beta2Interface {
+	return conversionAppsV1beta2Client{c.Interface, c.Interface.AppsV1beta2()}
+}
+
+func (c clientsetAdapter) AppsV1() appsv1.AppsV1Interface {
+	return conversionAppsV1Client{c.Interface, c.Interface.AppsV1()}
+}
+
+func (c clientsetAdapter) Apps() appsv1.AppsV1Interface {
+	return conversionAppsV1Client{c.Interface, c.Interface.AppsV1()}
+}
+
+type conversionAppsV1beta2Client struct {
+	clientset clientset.Interface
+	appsv1beta2.AppsV1beta2Interface
+}
+
+func (c conversionAppsV1beta2Client) ReplicaSets(namespace string) appsv1beta2.ReplicaSetInterface {
+	// TODO(enisoc): This will force RC integration tests to fail if anyone tries to update
+	// ReplicaSetController to use apps/v1beta2 without updating this conversion adapter.
+	// Please change conversionClient to use the new RS version instead of extensions/v1beta1,
+	// and then return a conversionClient here.
+	panic("need to update RC/RS conversionClient for apps/v1beta2")
+}
+
+type conversionAppsV1Client struct {
+	clientset clientset.Interface
+	appsv1.AppsV1Interface
+}
+
+func (c conversionAppsV1Client) ReplicaSets(namespace string) appsv1.ReplicaSetInterface {
+	// TODO(enisoc): This will force RC integration tests to fail if anyone tries to update
+	// ReplicaSetController to use apps/v1 without updating this conversion adapter.
+	// Please change conversionClient to use the new RS version instead of extensions/v1beta1,
+	// and then return a conversionClient here.
+	panic("need to update RC/RS conversionClient for apps/v1")
+}
+
+type conversionExtensionsClient struct {
+	clientset clientset.Interface
+	extensionsv1beta1client.ExtensionsV1beta1Interface
+}
+
+func (c conversionExtensionsClient) ReplicaSets(namespace string) extensionsv1beta1client.ReplicaSetInterface {
+	return conversionClient{c.clientset.CoreV1().ReplicationControllers(namespace)}
+}
+
+type conversionClient struct {
+	v1client.ReplicationControllerInterface
+}
+
+func (c conversionClient) Create(rs *extensionsv1beta1.ReplicaSet) (*extensionsv1beta1.ReplicaSet, error) {
+	return convertCall(c.ReplicationControllerInterface.Create, rs)
+}
+
+func (c conversionClient) Update(rs *extensionsv1beta1.ReplicaSet) (*extensionsv1beta1.ReplicaSet, error) {
+	return convertCall(c.ReplicationControllerInterface.Update, rs)
+}
+
+func (c conversionClient) UpdateStatus(rs *extensionsv1beta1.ReplicaSet) (*extensionsv1beta1.ReplicaSet, error) {
+	return convertCall(c.ReplicationControllerInterface.UpdateStatus, rs)
+}
+
+func (c conversionClient) Get(name string, options metav1.GetOptions) (*extensionsv1beta1.ReplicaSet, error) {
+	rc, err := c.ReplicationControllerInterface.Get(name, options)
+	if err != nil {
+		return nil, err
+	}
+	return convertRCtoRS(rc, nil)
+}
+
+func (c conversionClient) List(opts metav1.ListOptions) (*extensionsv1beta1.ReplicaSetList, error) {
+	rcList, err := c.ReplicationControllerInterface.List(opts)
+	if err != nil {
+		return nil, err
+	}
+	return convertList(rcList)
+}
+
+func (c conversionClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	// This is not used by RSC because we wrap the shared informer instead.
+	return nil, errors.New("Watch() is not implemented for conversionClient")
+}
+
+func (c conversionClient) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *extensionsv1beta1.ReplicaSet, err error) {
+	// This is not used by RSC.
+	return nil, errors.New("Patch() is not implemented for conversionClient")
+}
+
+func convertSlice(rcList []*v1.ReplicationController) ([]*extensionsv1beta1.ReplicaSet, error) {
+	rsList := make([]*extensionsv1beta1.ReplicaSet, 0, len(rcList))
+	for _, rc := range rcList {
+		rs, err := convertRCtoRS(rc, nil)
+		if err != nil {
+			return nil, err
+		}
+		rsList = append(rsList, rs)
+	}
+	return rsList, nil
+}
+
+func convertList(rcList *v1.ReplicationControllerList) (*extensionsv1beta1.ReplicaSetList, error) {
+	rsList := &extensionsv1beta1.ReplicaSetList{Items: make([]extensionsv1beta1.ReplicaSet, len(rcList.Items))}
+	for i := range rcList.Items {
+		rc := &rcList.Items[i]
+		_, err := convertRCtoRS(rc, &rsList.Items[i])
+		if err != nil {
+			return nil, err
+		}
+	}
+	return rsList, nil
+}
+
+func convertCall(fn func(*v1.ReplicationController) (*v1.ReplicationController, error), rs *extensionsv1beta1.ReplicaSet) (*extensionsv1beta1.ReplicaSet, error) {
+	rc, err := convertRStoRC(rs)
+	if err != nil {
+		return nil, err
+	}
+	result, err := fn(rc)
+	if err != nil {
+		return nil, err
+	}
+	return convertRCtoRS(result, nil)
+}
+
+func convertRCtoRS(rc *v1.ReplicationController, out *extensionsv1beta1.ReplicaSet) (*extensionsv1beta1.ReplicaSet, error) {
+	var rsInternal extensions.ReplicaSet
+	if err := apiv1.Convert_v1_ReplicationController_to_extensions_ReplicaSet(rc, &rsInternal, nil); err != nil {
+		return nil, fmt.Errorf("can't convert ReplicationController %v/%v to ReplicaSet: %v", rc.Namespace, rc.Name, err)
+	}
+	if out == nil {
+		out = new(extensionsv1beta1.ReplicaSet)
+	}
+	if err := extensionsinternalv1beta1.Convert_extensions_ReplicaSet_To_v1beta1_ReplicaSet(&rsInternal, out, nil); err != nil {
+		return nil, fmt.Errorf("can't convert ReplicaSet (converted from ReplicationController %v/%v) from internal to extensions/v1beta1: %v", rc.Namespace, rc.Name, err)
+	}
+	return out, nil
+}
+
+func convertRStoRC(rs *extensionsv1beta1.ReplicaSet) (*v1.ReplicationController, error) {
+	var rsInternal extensions.ReplicaSet
+	if err := extensionsinternalv1beta1.Convert_v1beta1_ReplicaSet_To_extensions_ReplicaSet(rs, &rsInternal, nil); err != nil {
+		return nil, fmt.Errorf("can't convert ReplicaSet (converting to ReplicationController %v/%v) from extensions/v1beta1 to internal: %v", rs.Namespace, rs.Name, err)
+	}
+	var rc v1.ReplicationController
+	if err := apiv1.Convert_extensions_ReplicaSet_to_v1_ReplicationController(&rsInternal, &rc, nil); err != nil {
+		return nil, fmt.Errorf("can't convert ReplicaSet to ReplicationController %v/%v: %v", rs.Namespace, rs.Name, err)
+	}
+	return &rc, nil
+}
+
+type podControlAdapter struct {
+	controller.PodControlInterface
+}
+
+func (pc podControlAdapter) CreatePods(namespace string, template *v1.PodTemplateSpec, object runtime.Object) error {
+	// This is not used by RSC.
+	return errors.New("CreatePods() is not implemented for podControlAdapter")
+}
+
+func (pc podControlAdapter) CreatePodsOnNode(nodeName, namespace string, template *v1.PodTemplateSpec, object runtime.Object, controllerRef *metav1.OwnerReference) error {
+	// This is not used by RSC.
+	return errors.New("CreatePodsOnNode() is not implemented for podControlAdapter")
+}
+
+func (pc podControlAdapter) CreatePodsWithControllerRef(namespace string, template *v1.PodTemplateSpec, object runtime.Object, controllerRef *metav1.OwnerReference) error {
+	rc, err := convertRStoRC(object.(*extensionsv1beta1.ReplicaSet))
+	if err != nil {
+		return err
+	}
+	return pc.PodControlInterface.CreatePodsWithControllerRef(namespace, template, rc, controllerRef)
+}
+
+func (pc podControlAdapter) DeletePod(namespace string, podID string, object runtime.Object) error {
+	rc, err := convertRStoRC(object.(*extensionsv1beta1.ReplicaSet))
+	if err != nil {
+		return err
+	}
+	return pc.PodControlInterface.DeletePod(namespace, podID, rc)
+}

vendor/k8s.io/kubernetes/pkg/controller/replication/doc.go

@@ -0,0 +1,19 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package replication contains logic for watching and synchronizing
+// replication controllers.
+package replication // import "k8s.io/kubernetes/pkg/controller/replication"

vendor/k8s.io/kubernetes/pkg/controller/replication/replication_controller.go

@@ -0,0 +1,67 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// ### ATTENTION ###
+//
+// ReplicationManager is now just a wrapper around ReplicaSetController,
+// with a conversion layer that effectively treats ReplicationController
+// as if it were an older API version of ReplicaSet.
+//
+// However, RC and RS still have separate storage and separate instantiations
+// of the ReplicaSetController object.
+
+package replication
+
+import (
+	"github.com/golang/glog"
+	"k8s.io/api/core/v1"
+	coreinformers "k8s.io/client-go/informers/core/v1"
+	clientset "k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/kubernetes/scheme"
+	v1core "k8s.io/client-go/kubernetes/typed/core/v1"
+	"k8s.io/client-go/tools/record"
+	"k8s.io/kubernetes/pkg/controller"
+	"k8s.io/kubernetes/pkg/controller/replicaset"
+)
+
+const (
+	BurstReplicas = replicaset.BurstReplicas
+)
+
+// ReplicationManager is responsible for synchronizing ReplicationController objects stored
+// in the system with actual running pods.
+// It is actually just a wrapper around ReplicaSetController.
+type ReplicationManager struct {
+	replicaset.ReplicaSetController
+}
+
+// NewReplicationManager configures a replication manager with the specified event recorder
+func NewReplicationManager(podInformer coreinformers.PodInformer, rcInformer coreinformers.ReplicationControllerInformer, kubeClient clientset.Interface, burstReplicas int) *ReplicationManager {
+	eventBroadcaster := record.NewBroadcaster()
+	eventBroadcaster.StartLogging(glog.Infof)
+	eventBroadcaster.StartRecordingToSink(&v1core.EventSinkImpl{Interface: v1core.New(kubeClient.CoreV1().RESTClient()).Events("")})
+	return &ReplicationManager{
+		*replicaset.NewBaseController(informerAdapter{rcInformer}, podInformer, clientsetAdapter{kubeClient}, burstReplicas,
+			v1.SchemeGroupVersion.WithKind("ReplicationController"),
+			"replication_controller",
+			"replicationmanager",
+			podControlAdapter{controller.RealPodControl{
+				KubeClient: kubeClient,
+				Recorder:   eventBroadcaster.NewRecorder(scheme.Scheme, v1.EventSource{Component: "replication-controller"}),
+			}},
+		),
+	}
+}

vendor/k8s.io/kubernetes/pkg/controller/replication/replication_controller_utils.go

@@ -0,0 +1,73 @@
+/*
+Copyright 2015 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.
+*/
+
+// If you make changes to this file, you should also make the corresponding change in ReplicaSet.
+
+package replication
+
+import (
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// NewReplicationControllerCondition creates a new replication controller condition.
+func NewReplicationControllerCondition(condType v1.ReplicationControllerConditionType, status v1.ConditionStatus, reason, msg string) v1.ReplicationControllerCondition {
+	return v1.ReplicationControllerCondition{
+		Type:               condType,
+		Status:             status,
+		LastTransitionTime: metav1.Now(),
+		Reason:             reason,
+		Message:            msg,
+	}
+}
+
+// GetCondition returns a replication controller condition with the provided type if it exists.
+func GetCondition(status v1.ReplicationControllerStatus, condType v1.ReplicationControllerConditionType) *v1.ReplicationControllerCondition {
+	for i := range status.Conditions {
+		c := status.Conditions[i]
+		if c.Type == condType {
+			return &c
+		}
+	}
+	return nil
+}
+
+// SetCondition adds/replaces the given condition in the replication controller status.
+func SetCondition(status *v1.ReplicationControllerStatus, condition v1.ReplicationControllerCondition) {
+	currentCond := GetCondition(*status, condition.Type)
+	if currentCond != nil && currentCond.Status == condition.Status && currentCond.Reason == condition.Reason {
+		return
+	}
+	newConditions := filterOutCondition(status.Conditions, condition.Type)
+	status.Conditions = append(newConditions, condition)
+}
+
+// RemoveCondition removes the condition with the provided type from the replication controller status.
+func RemoveCondition(status *v1.ReplicationControllerStatus, condType v1.ReplicationControllerConditionType) {
+	status.Conditions = filterOutCondition(status.Conditions, condType)
+}
+
+// filterOutCondition returns a new slice of replication controller conditions without conditions with the provided type.
+func filterOutCondition(conditions []v1.ReplicationControllerCondition, condType v1.ReplicationControllerConditionType) []v1.ReplicationControllerCondition {
+	var newConditions []v1.ReplicationControllerCondition
+	for _, c := range conditions {
+		if c.Type == condType {
+			continue
+		}
+		newConditions = append(newConditions, c)
+	}
+	return newConditions
+}

vendor/k8s.io/kubernetes/pkg/controller/replication/replication_controller_utils_test.go

@@ -0,0 +1,184 @@
+/*
+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 replication
+
+import (
+	"reflect"
+	"testing"
+
+	"k8s.io/api/core/v1"
+)
+
+var (
+	imagePullBackOff v1.ReplicationControllerConditionType = "ImagePullBackOff"
+
+	condImagePullBackOff = func() v1.ReplicationControllerCondition {
+		return v1.ReplicationControllerCondition{
+			Type:   imagePullBackOff,
+			Status: v1.ConditionTrue,
+			Reason: "NonExistentImage",
+		}
+	}
+
+	condReplicaFailure = func() v1.ReplicationControllerCondition {
+		return v1.ReplicationControllerCondition{
+			Type:   v1.ReplicationControllerReplicaFailure,
+			Status: v1.ConditionTrue,
+			Reason: "OtherFailure",
+		}
+	}
+
+	condReplicaFailure2 = func() v1.ReplicationControllerCondition {
+		return v1.ReplicationControllerCondition{
+			Type:   v1.ReplicationControllerReplicaFailure,
+			Status: v1.ConditionTrue,
+			Reason: "AnotherFailure",
+		}
+	}
+
+	status = func() *v1.ReplicationControllerStatus {
+		return &v1.ReplicationControllerStatus{
+			Conditions: []v1.ReplicationControllerCondition{condReplicaFailure()},
+		}
+	}
+)
+
+func TestGetCondition(t *testing.T) {
+	exampleStatus := status()
+
+	tests := []struct {
+		name string
+
+		status     v1.ReplicationControllerStatus
+		condType   v1.ReplicationControllerConditionType
+		condStatus v1.ConditionStatus
+		condReason string
+
+		expected bool
+	}{
+		{
+			name: "condition exists",
+
+			status:   *exampleStatus,
+			condType: v1.ReplicationControllerReplicaFailure,
+
+			expected: true,
+		},
+		{
+			name: "condition does not exist",
+
+			status:   *exampleStatus,
+			condType: imagePullBackOff,
+
+			expected: false,
+		},
+	}
+
+	for _, test := range tests {
+		cond := GetCondition(test.status, test.condType)
+		exists := cond != nil
+		if exists != test.expected {
+			t.Errorf("%s: expected condition to exist: %t, got: %t", test.name, test.expected, exists)
+		}
+	}
+}
+
+func TestSetCondition(t *testing.T) {
+	tests := []struct {
+		name string
+
+		status *v1.ReplicationControllerStatus
+		cond   v1.ReplicationControllerCondition
+
+		expectedStatus *v1.ReplicationControllerStatus
+	}{
+		{
+			name: "set for the first time",
+
+			status: &v1.ReplicationControllerStatus{},
+			cond:   condReplicaFailure(),
+
+			expectedStatus: &v1.ReplicationControllerStatus{Conditions: []v1.ReplicationControllerCondition{condReplicaFailure()}},
+		},
+		{
+			name: "simple set",
+
+			status: &v1.ReplicationControllerStatus{Conditions: []v1.ReplicationControllerCondition{condImagePullBackOff()}},
+			cond:   condReplicaFailure(),
+
+			expectedStatus: &v1.ReplicationControllerStatus{Conditions: []v1.ReplicationControllerCondition{condImagePullBackOff(), condReplicaFailure()}},
+		},
+		{
+			name: "overwrite",
+
+			status: &v1.ReplicationControllerStatus{Conditions: []v1.ReplicationControllerCondition{condReplicaFailure()}},
+			cond:   condReplicaFailure2(),
+
+			expectedStatus: &v1.ReplicationControllerStatus{Conditions: []v1.ReplicationControllerCondition{condReplicaFailure2()}},
+		},
+	}
+
+	for _, test := range tests {
+		SetCondition(test.status, test.cond)
+		if !reflect.DeepEqual(test.status, test.expectedStatus) {
+			t.Errorf("%s: expected status: %v, got: %v", test.name, test.expectedStatus, test.status)
+		}
+	}
+}
+
+func TestRemoveCondition(t *testing.T) {
+	tests := []struct {
+		name string
+
+		status   *v1.ReplicationControllerStatus
+		condType v1.ReplicationControllerConditionType
+
+		expectedStatus *v1.ReplicationControllerStatus
+	}{
+		{
+			name: "remove from empty status",
+
+			status:   &v1.ReplicationControllerStatus{},
+			condType: v1.ReplicationControllerReplicaFailure,
+
+			expectedStatus: &v1.ReplicationControllerStatus{},
+		},
+		{
+			name: "simple remove",
+
+			status:   &v1.ReplicationControllerStatus{Conditions: []v1.ReplicationControllerCondition{condReplicaFailure()}},
+			condType: v1.ReplicationControllerReplicaFailure,
+
+			expectedStatus: &v1.ReplicationControllerStatus{},
+		},
+		{
+			name: "doesn't remove anything",
+
+			status:   status(),
+			condType: imagePullBackOff,
+
+			expectedStatus: status(),
+		},
+	}
+
+	for _, test := range tests {
+		RemoveCondition(test.status, test.condType)
+		if !reflect.DeepEqual(test.status, test.expectedStatus) {
+			t.Errorf("%s: expected status: %v, got: %v", test.name, test.expectedStatus, test.status)
+		}
+	}
+}