Merge pull request #39355 from kargakis/update-rc-manager

cmd/kube-controller-manager/app/core.go

@@ -55,8 +55,8 @@ func startEndpointController(ctx ControllerContext) (bool, error) {
 func startReplicationController(ctx ControllerContext) (bool, error) {
 	go replicationcontroller.NewReplicationManager(
 		ctx.InformerFactory.Pods().Informer(),
+		ctx.InformerFactory.ReplicationControllers().Informer(),
 		ctx.ClientBuilder.ClientOrDie("replication-controller"),
-		ResyncPeriod(&ctx.Options),
 		replicationcontroller.BurstReplicas,
 		int(ctx.Options.LookupCacheSizeForRC),
 		ctx.Options.EnableGarbageCollector,

pkg/controller/informers/core.go

@@ -318,6 +318,42 @@ func (f *internalLimitRangeInformer) Lister() coreinternallisters.LimitRangeList
 
 //*****************************************************************************
 
+// ReplicationControllerInformer is type of SharedIndexInformer which watches and lists all replication controllers.
+// Interface provides constructor for informer and lister for replication controllers.
+type ReplicationControllerInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() *cache.StoreToReplicationControllerLister
+}
+
+type replicationControllerInformer struct {
+	*sharedInformerFactory
+}
+
+// Informer checks whether replicationControllerInformer exists in sharedInformerFactory and if not, it creates new informer of type
+// replicationControllerInformer and connects it to sharedInformerFactory
+func (f *replicationControllerInformer) Informer() cache.SharedIndexInformer {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+
+	informerType := reflect.TypeOf(&v1.ReplicationController{})
+	informer, exists := f.informers[informerType]
+	if exists {
+		return informer
+	}
+	informer = NewReplicationControllerInformer(f.client, f.defaultResync)
+	f.informers[informerType] = informer
+
+	return informer
+}
+
+// Lister returns lister for replicationControllerInformer
+func (f *replicationControllerInformer) Lister() *cache.StoreToReplicationControllerLister {
+	informer := f.Informer()
+	return &cache.StoreToReplicationControllerLister{Indexer: informer.GetIndexer()}
+}
+
+//*****************************************************************************
+
 // NewPodInformer returns a SharedIndexInformer that lists and watches all pods
 func NewPodInformer(client clientset.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
 	sharedIndexInformer := cache.NewSharedIndexInformer(
@@ -350,7 +386,7 @@ func NewNodeInformer(client clientset.Interface, resyncPeriod time.Duration) cac
 		},
 		&v1.Node{},
 		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+		cache.Indexers{})
 
 	return sharedIndexInformer
 }
@@ -445,7 +481,7 @@ func NewLimitRangeInformer(client clientset.Interface, resyncPeriod time.Duratio
 		},
 		&v1.LimitRange{},
 		resyncPeriod,
-		cache.Indexers{})
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
 
 	return sharedIndexInformer
 }
@@ -472,6 +508,25 @@ func NewInternalLimitRangeInformer(internalclient internalclientset.Interface, r
 	return sharedIndexInformer
 }
 
+// NewReplicationControllerInformer returns a SharedIndexInformer that lists and watches all replication controllers.
+func NewReplicationControllerInformer(client clientset.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+				return client.Core().ReplicationControllers(v1.NamespaceAll).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				return client.Core().ReplicationControllers(v1.NamespaceAll).Watch(options)
+			},
+		},
+		&v1.ReplicationController{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
 /*****************************************************************************/
 
 // ServiceAccountInformer is type of SharedIndexInformer which watches and lists all ServiceAccounts.

pkg/controller/informers/factory.go

@@ -52,6 +52,7 @@ type SharedInformerFactory interface {
 	DaemonSets() DaemonSetInformer
 	Deployments() DeploymentInformer
 	ReplicaSets() ReplicaSetInformer
+	ReplicationControllers() ReplicationControllerInformer
 
 	ClusterRoleBindings() ClusterRoleBindingInformer
 	ClusterRoles() ClusterRoleInformer
@@ -151,6 +152,10 @@ func (f *sharedInformerFactory) ReplicaSets() ReplicaSetInformer {
 	return &replicaSetInformer{sharedInformerFactory: f}
 }
 
+func (f *sharedInformerFactory) ReplicationControllers() ReplicationControllerInformer {
+	return &replicationControllerInformer{sharedInformerFactory: f}
+}
+
 func (f *sharedInformerFactory) ClusterRoles() ClusterRoleInformer {
 	return &clusterRoleInformer{sharedInformerFactory: f}
 }

pkg/controller/replicaset/replica_set.go

@@ -47,19 +47,10 @@ import (
 )
 
 const (
-	// We'll attempt to recompute the required replicas of all ReplicaSets
-	// that have fulfilled their expectations at least this often. This recomputation
-	// happens based on contents in local pod storage.
-	FullControllerResyncPeriod = 30 * time.Second
-
 	// Realistic value of the burstReplica field for the replica set manager based off
 	// performance requirements for kubernetes 1.0.
 	BurstReplicas = 500
 
-	// We must avoid counting pods until the pod store has synced. If it hasn't synced, to
-	// avoid a hot loop, we'll wait this long between checks.
-	PodStoreSyncedPollPeriod = 100 * time.Millisecond
-
 	// The number of times we retry updating a ReplicaSet's status.
 	statusUpdateRetries = 1
 )
@@ -568,14 +559,14 @@ func (rsc *ReplicaSetController) syncReplicaSet(key string) error {
 	}()
 
 	obj, exists, err := rsc.rsLister.Indexer.GetByKey(key)
+	if err != nil {
+		return err
+	}
 	if !exists {
 		glog.V(4).Infof("ReplicaSet has been deleted %v", key)
 		rsc.expectations.DeleteExpectations(key)
 		return nil
 	}
-	if err != nil {
-		return err
-	}
 	rs := *obj.(*extensions.ReplicaSet)
 
 	rsNeedsSync := rsc.expectations.SatisfiedExpectations(key)

pkg/controller/replication/BUILD

@@ -27,7 +27,6 @@ go_library(
         "//pkg/controller:go_default_library",
         "//pkg/controller/informers:go_default_library",
         "//pkg/labels:go_default_library",
-        "//pkg/runtime:go_default_library",
         "//pkg/runtime/schema:go_default_library",
         "//pkg/util:go_default_library",
         "//pkg/util/errors:go_default_library",
@@ -35,7 +34,6 @@ go_library(
         "//pkg/util/runtime:go_default_library",
         "//pkg/util/wait:go_default_library",
         "//pkg/util/workqueue:go_default_library",
-        "//pkg/watch:go_default_library",
         "//vendor:github.com/golang/glog",
     ],
 )
@@ -57,6 +55,7 @@ go_test(
         "//pkg/client/restclient:go_default_library",
         "//pkg/client/testing/core:go_default_library",
         "//pkg/controller:go_default_library",
+        "//pkg/controller/informers:go_default_library",
         "//pkg/runtime:go_default_library",
         "//pkg/securitycontext:go_default_library",
         "//pkg/util/sets:go_default_library",

plugin/pkg/auth/authorizer/rbac/bootstrappolicy/policy.go

@@ -250,7 +250,7 @@ func ClusterRoles() []rbac.ClusterRole {
 				rbac.NewRule("update").Groups(legacyGroup).Resources("endpoints", "serviceaccounts").RuleOrDie(),
 
 				rbac.NewRule("list", "watch").Groups("*").Resources("namespaces", "nodes", "persistentvolumeclaims",
-					"persistentvolumes", "pods", "secrets", "serviceaccounts").RuleOrDie(),
+					"persistentvolumes", "pods", "secrets", "serviceaccounts", "replicationcontrollers").RuleOrDie(),
 				rbac.NewRule("list", "watch").Groups(extensionsGroup).Resources("daemonsets", "deployments", "replicasets").RuleOrDie(),
 				rbac.NewRule("list", "watch").Groups(batchGroup).Resources("jobs", "cronjobs").RuleOrDie(),
 			},

plugin/pkg/auth/authorizer/rbac/bootstrappolicy/testdata/cluster-roles.yaml

@@ -447,6 +447,7 @@ items:
     - persistentvolumeclaims
     - persistentvolumes
     - pods
+    - replicationcontrollers
     - secrets
     - serviceaccounts
     verbs:

test/integration/quota/quota_test.go

@@ -31,8 +31,10 @@ import (
 	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/clientset"
 	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
+	"k8s.io/kubernetes/pkg/client/record"
 	"k8s.io/kubernetes/pkg/client/restclient"
 	"k8s.io/kubernetes/pkg/controller"
+	"k8s.io/kubernetes/pkg/controller/informers"
 	replicationcontroller "k8s.io/kubernetes/pkg/controller/replication"
 	resourcequotacontroller "k8s.io/kubernetes/pkg/controller/resourcequota"
 	"k8s.io/kubernetes/pkg/fields"
@@ -82,8 +84,13 @@ func TestQuota(t *testing.T) {
 	controllerCh := make(chan struct{})
 	defer close(controllerCh)
 
-	go replicationcontroller.NewReplicationManagerFromClientForIntegration(clientset, controller.NoResyncPeriodFunc, replicationcontroller.BurstReplicas, 4096).
-		Run(3, controllerCh)
+	informers := informers.NewSharedInformerFactory(clientset, nil, controller.NoResyncPeriodFunc())
+	podInformer := informers.Pods().Informer()
+	rcInformer := informers.ReplicationControllers().Informer()
+	rm := replicationcontroller.NewReplicationManager(podInformer, rcInformer, clientset, replicationcontroller.BurstReplicas, 4096, false)
+	rm.SetEventRecorder(&record.FakeRecorder{})
+	informers.Start(controllerCh)
+	go rm.Run(3, controllerCh)
 
 	resourceQuotaRegistry := quotainstall.NewRegistry(clientset, nil)
 	groupKindsToReplenish := []schema.GroupKind{

test/integration/replicationcontroller/replicationcontroller_test.go

@@ -123,7 +123,7 @@ func verifyRemainingObjects(t *testing.T, clientSet clientset.Interface, namespa
 	return ret, nil
 }
 
-func rmSetup(t *testing.T, enableGarbageCollector bool) (*httptest.Server, *replication.ReplicationManager, cache.SharedIndexInformer, clientset.Interface) {
+func rmSetup(t *testing.T, stopCh chan struct{}, enableGarbageCollector bool) (*httptest.Server, *replication.ReplicationManager, cache.SharedIndexInformer, clientset.Interface) {
 	masterConfig := framework.NewIntegrationTestMasterConfig()
 	_, s := framework.RunAMaster(masterConfig)
 
@@ -133,22 +133,13 @@ func rmSetup(t *testing.T, enableGarbageCollector bool) (*httptest.Server, *repl
 		t.Fatalf("Error in create clientset: %v", err)
 	}
 	resyncPeriod := 12 * time.Hour
-	resyncPeriodFunc := func() time.Duration {
-		return resyncPeriod
-	}
-	podInformer := informers.NewPodInformer(clientset.NewForConfigOrDie(restclient.AddUserAgent(&config, "pod-informer")), resyncPeriod)
-	rm := replication.NewReplicationManager(
-		podInformer,
-		clientset.NewForConfigOrDie(restclient.AddUserAgent(&config, "replication-controller")),
-		resyncPeriodFunc,
-		replication.BurstReplicas,
-		4096,
-		enableGarbageCollector,
-	)
 
-	if err != nil {
-		t.Fatalf("Failed to create replication manager")
-	}
+	informers := informers.NewSharedInformerFactory(clientSet, nil, resyncPeriod)
+	podInformer := informers.Pods().Informer()
+	rcInformer := informers.ReplicationControllers().Informer()
+	rm := replication.NewReplicationManager(podInformer, rcInformer, clientSet, replication.BurstReplicas, 4096, enableGarbageCollector)
+	informers.Start(stopCh)
+
 	return s, rm, podInformer, clientSet
 }
 
@@ -219,7 +210,8 @@ func TestAdoption(t *testing.T) {
 		},
 	}
 	for i, tc := range testCases {
-		s, rm, podInformer, clientSet := rmSetup(t, true)
+		stopCh := make(chan struct{})
+		s, rm, podInformer, clientSet := rmSetup(t, stopCh, true)
 		ns := framework.CreateTestingNamespace(fmt.Sprintf("adoption-%d", i), s, t)
 		defer framework.DeleteTestingNamespace(ns, s, t)
 
@@ -238,7 +230,6 @@ func TestAdoption(t *testing.T) {
 			t.Fatalf("Failed to create Pod: %v", err)
 		}
 
-		stopCh := make(chan struct{})
 		go podInformer.Run(stopCh)
 		waitToObservePods(t, podInformer, 1)
 		go rm.Run(5, stopCh)
@@ -296,7 +287,8 @@ func TestUpdateSelectorToAdopt(t *testing.T) {
 	// We have pod1, pod2 and rc. rc.spec.replicas=1. At first rc.Selector
 	// matches pod1 only; change the selector to match pod2 as well. Verify
 	// there is only one pod left.
-	s, rm, podInformer, clientSet := rmSetup(t, true)
+	stopCh := make(chan struct{})
+	s, rm, _, clientSet := rmSetup(t, stopCh, true)
 	ns := framework.CreateTestingNamespace("update-selector-to-adopt", s, t)
 	defer framework.DeleteTestingNamespace(ns, s, t)
 	rc := newRC("rc", ns.Name, 1)
@@ -309,8 +301,6 @@ func TestUpdateSelectorToAdopt(t *testing.T) {
 	pod2.Labels["uniqueKey"] = "2"
 	createRCsPods(t, clientSet, []*v1.ReplicationController{rc}, []*v1.Pod{pod1, pod2}, ns.Name)
 
-	stopCh := make(chan struct{})
-	go podInformer.Run(stopCh)
 	go rm.Run(5, stopCh)
 	waitRCStable(t, clientSet, rc, ns.Name)
 
@@ -336,7 +326,8 @@ func TestUpdateSelectorToRemoveControllerRef(t *testing.T) {
 	// matches pod1 and pod2; change the selector to match only pod1. Verify
 	// that rc creates one more pod, so there are 3 pods. Also verify that
 	// pod2's controllerRef is cleared.
-	s, rm, podInformer, clientSet := rmSetup(t, true)
+	stopCh := make(chan struct{})
+	s, rm, podInformer, clientSet := rmSetup(t, stopCh, true)
 	ns := framework.CreateTestingNamespace("update-selector-to-remove-controllerref", s, t)
 	defer framework.DeleteTestingNamespace(ns, s, t)
 	rc := newRC("rc", ns.Name, 2)
@@ -346,8 +337,6 @@ func TestUpdateSelectorToRemoveControllerRef(t *testing.T) {
 	pod2.Labels["uniqueKey"] = "2"
 	createRCsPods(t, clientSet, []*v1.ReplicationController{rc}, []*v1.Pod{pod1, pod2}, ns.Name)
 
-	stopCh := make(chan struct{})
-	go podInformer.Run(stopCh)
 	waitToObservePods(t, podInformer, 2)
 	go rm.Run(5, stopCh)
 	waitRCStable(t, clientSet, rc, ns.Name)
@@ -382,7 +371,8 @@ func TestUpdateLabelToRemoveControllerRef(t *testing.T) {
 	// matches pod1 and pod2; change pod2's labels to non-matching. Verify
 	// that rc creates one more pod, so there are 3 pods. Also verify that
 	// pod2's controllerRef is cleared.
-	s, rm, podInformer, clientSet := rmSetup(t, true)
+	stopCh := make(chan struct{})
+	s, rm, _, clientSet := rmSetup(t, stopCh, true)
 	ns := framework.CreateTestingNamespace("update-label-to-remove-controllerref", s, t)
 	defer framework.DeleteTestingNamespace(ns, s, t)
 	rc := newRC("rc", ns.Name, 2)
@@ -390,8 +380,6 @@ func TestUpdateLabelToRemoveControllerRef(t *testing.T) {
 	pod2 := newMatchingPod("pod2", ns.Name)
 	createRCsPods(t, clientSet, []*v1.ReplicationController{rc}, []*v1.Pod{pod1, pod2}, ns.Name)
 
-	stopCh := make(chan struct{})
-	go podInformer.Run(stopCh)
 	go rm.Run(5, stopCh)
 	waitRCStable(t, clientSet, rc, ns.Name)
 
@@ -424,7 +412,8 @@ func TestUpdateLabelToBeAdopted(t *testing.T) {
 	// matches pod1 only; change pod2's labels to be matching. Verify the RC
 	// controller adopts pod2 and delete one of them, so there is only 1 pod
 	// left.
-	s, rm, podInformer, clientSet := rmSetup(t, true)
+	stopCh := make(chan struct{})
+	s, rm, _, clientSet := rmSetup(t, stopCh, true)
 	ns := framework.CreateTestingNamespace("update-label-to-be-adopted", s, t)
 	defer framework.DeleteTestingNamespace(ns, s, t)
 	rc := newRC("rc", ns.Name, 1)
@@ -437,8 +426,6 @@ func TestUpdateLabelToBeAdopted(t *testing.T) {
 	pod2.Labels["uniqueKey"] = "2"
 	createRCsPods(t, clientSet, []*v1.ReplicationController{rc}, []*v1.Pod{pod1, pod2}, ns.Name)
 
-	stopCh := make(chan struct{})
-	go podInformer.Run(stopCh)
 	go rm.Run(5, stopCh)
 	waitRCStable(t, clientSet, rc, ns.Name)