Merge pull request #42056 from ncdc/shared-informers-16-remove-legacy-code

cmd/cloud-controller-manager/app/BUILD

@@ -21,7 +21,6 @@ go_library(
         "//pkg/cloudprovider:go_default_library",
         "//pkg/controller:go_default_library",
         "//pkg/controller/cloud:go_default_library",
-        "//pkg/controller/informers:go_default_library",
         "//pkg/controller/route:go_default_library",
         "//pkg/controller/service:go_default_library",
         "//pkg/util/configz:go_default_library",

cmd/cloud-controller-manager/app/controllermanager.go

@@ -36,13 +36,12 @@ import (
 	"k8s.io/kubernetes/cmd/cloud-controller-manager/app/options"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/client/clientset_generated/clientset"
-	newinformers "k8s.io/kubernetes/pkg/client/informers/informers_generated/externalversions"
+	informers "k8s.io/kubernetes/pkg/client/informers/informers_generated/externalversions"
 	"k8s.io/kubernetes/pkg/client/leaderelection"
 	"k8s.io/kubernetes/pkg/client/leaderelection/resourcelock"
 	"k8s.io/kubernetes/pkg/cloudprovider"
 	"k8s.io/kubernetes/pkg/controller"
 	nodecontroller "k8s.io/kubernetes/pkg/controller/cloud"
-	"k8s.io/kubernetes/pkg/controller/informers"
 	routecontroller "k8s.io/kubernetes/pkg/controller/route"
 	servicecontroller "k8s.io/kubernetes/pkg/controller/service"
 	"k8s.io/kubernetes/pkg/util/configz"
@@ -196,9 +195,7 @@ func StartControllers(s *options.CloudControllerManagerServer, kubeconfig *restc
 		return rootClientBuilder.ClientOrDie(serviceAccountName)
 	}
 	versionedClient := client("shared-informers")
-	// TODO replace sharedInformers with newSharedInformers
-	sharedInformers := informers.NewSharedInformerFactory(versionedClient, nil, resyncPeriod(s)())
-	newSharedInformers := newinformers.NewSharedInformerFactory(versionedClient, resyncPeriod(s)())
+	sharedInformers := informers.NewSharedInformerFactory(versionedClient, resyncPeriod(s)())
 
 	_, clusterCIDR, err := net.ParseCIDR(s.ClusterCIDR)
 	if err != nil {
@@ -207,7 +204,7 @@ func StartControllers(s *options.CloudControllerManagerServer, kubeconfig *restc
 
 	// Start the CloudNodeController
 	nodeController, err := nodecontroller.NewCloudNodeController(
-		newSharedInformers.Core().V1().Nodes(),
+		sharedInformers.Core().V1().Nodes(),
 		client("cloud-node-controller"), cloud,
 		s.NodeMonitorPeriod.Duration)
 	if err != nil {
@@ -220,8 +217,8 @@ func StartControllers(s *options.CloudControllerManagerServer, kubeconfig *restc
 	serviceController, err := servicecontroller.New(
 		cloud,
 		client("service-controller"),
-		newSharedInformers.Core().V1().Services(),
-		newSharedInformers.Core().V1().Nodes(),
+		sharedInformers.Core().V1().Services(),
+		sharedInformers.Core().V1().Nodes(),
 		s.ClusterName,
 	)
 	if err != nil {
@@ -236,7 +233,7 @@ func StartControllers(s *options.CloudControllerManagerServer, kubeconfig *restc
 		if routes, ok := cloud.Routes(); !ok {
 			glog.Warning("configure-cloud-routes is set, but cloud provider does not support routes. Will not configure cloud provider routes.")
 		} else {
-			routeController := routecontroller.New(routes, client("route-controller"), newSharedInformers.Core().V1().Nodes(), s.ClusterName, clusterCIDR)
+			routeController := routecontroller.New(routes, client("route-controller"), sharedInformers.Core().V1().Nodes(), s.ClusterName, clusterCIDR)
 			routeController.Run(stop, s.RouteReconciliationPeriod.Duration)
 			time.Sleep(wait.Jitter(s.ControllerStartInterval.Duration, ControllerStartJitter))
 		}
@@ -258,9 +255,7 @@ func StartControllers(s *options.CloudControllerManagerServer, kubeconfig *restc
 		glog.Fatalf("Failed to get api versions from server: %v", err)
 	}
 
-	// TODO replace sharedInformers with newSharedInformers
 	sharedInformers.Start(stop)
-	newSharedInformers.Start(stop)
 
 	select {}
 }

cmd/kube-controller-manager/app/BUILD

@@ -52,7 +52,6 @@ go_library(
         "//pkg/controller/endpoint:go_default_library",
         "//pkg/controller/garbagecollector:go_default_library",
         "//pkg/controller/garbagecollector/metaonly:go_default_library",
-        "//pkg/controller/informers:go_default_library",
         "//pkg/controller/job:go_default_library",
         "//pkg/controller/namespace:go_default_library",
         "//pkg/controller/node:go_default_library",

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

@@ -30,8 +30,9 @@ func startStatefulSetController(ctx ControllerContext) (bool, error) {
 		return false, nil
 	}
 	go statefulset.NewStatefulSetController(
-		ctx.NewInformerFactory.Core().V1().Pods(),
-		ctx.NewInformerFactory.Apps().V1beta1().StatefulSets(),
+		ctx.InformerFactory.Core().V1().Pods(),
+		ctx.InformerFactory.Apps().V1beta1().StatefulSets(),
+		ctx.InformerFactory.Core().V1().PersistentVolumeClaims(),
 		ctx.ClientBuilder.ClientOrDie("statefulset-controller"),
 	).Run(1, ctx.Stop)
 	return true, nil

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

@@ -44,7 +44,7 @@ func startHPAController(ctx ControllerContext) (bool, error) {
 		hpaClient.Extensions(),
 		hpaClient.Autoscaling(),
 		replicaCalc,
-		ctx.NewInformerFactory.Autoscaling().V1().HorizontalPodAutoscalers(),
+		ctx.InformerFactory.Autoscaling().V1().HorizontalPodAutoscalers(),
 		ctx.Options.HorizontalPodAutoscalerSyncPeriod.Duration,
 	).Run(ctx.Stop)
 	return true, nil

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

@@ -33,8 +33,8 @@ func startJobController(ctx ControllerContext) (bool, error) {
 		return false, nil
 	}
 	go job.NewJobController(
-		ctx.NewInformerFactory.Core().V1().Pods(),
-		ctx.NewInformerFactory.Batch().V1().Jobs(),
+		ctx.InformerFactory.Core().V1().Pods(),
+		ctx.InformerFactory.Batch().V1().Jobs(),
 		ctx.ClientBuilder.ClientOrDie("job-controller"),
 	).Run(int(ctx.Options.ConcurrentJobSyncs), ctx.Stop)
 	return true, nil

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

@@ -41,7 +41,7 @@ func startCSRController(ctx ControllerContext) (bool, error) {
 
 	certController, err := certcontroller.NewCertificateController(
 		c,
-		ctx.NewInformerFactory.Certificates().V1beta1().CertificateSigningRequests(),
+		ctx.InformerFactory.Certificates().V1beta1().CertificateSigningRequests(),
 		signer,
 		certcontroller.NewGroupApprover(ctx.Options.ApproveAllKubeletCSRsForGroup),
 	)

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

@@ -46,12 +46,11 @@ import (
 	"k8s.io/kubernetes/cmd/kube-controller-manager/app/options"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/client/clientset_generated/clientset"
-	newinformers "k8s.io/kubernetes/pkg/client/informers/informers_generated/externalversions"
+	informers "k8s.io/kubernetes/pkg/client/informers/informers_generated/externalversions"
 	"k8s.io/kubernetes/pkg/client/leaderelection"
 	"k8s.io/kubernetes/pkg/client/leaderelection/resourcelock"
 	"k8s.io/kubernetes/pkg/cloudprovider"
 	"k8s.io/kubernetes/pkg/controller"
-	"k8s.io/kubernetes/pkg/controller/informers"
 	nodecontroller "k8s.io/kubernetes/pkg/controller/node"
 	routecontroller "k8s.io/kubernetes/pkg/controller/route"
 	servicecontroller "k8s.io/kubernetes/pkg/controller/service"
@@ -216,13 +215,8 @@ type ControllerContext struct {
 	ClientBuilder controller.ControllerClientBuilder
 
 	// InformerFactory gives access to informers for the controller.
-	// TODO delete this instance once the conversion to generated informers is complete.
 	InformerFactory informers.SharedInformerFactory
 
-	// NewInformerFactory gives access to informers for the controller.
-	// TODO rename this to InformerFactory once the conversion to generated informers is complete.
-	NewInformerFactory newinformers.SharedInformerFactory
-
 	// Options provides access to init options for a given controller
 	Options options.CMServer
 
@@ -343,9 +337,7 @@ func getAvailableResources(clientBuilder controller.ControllerClientBuilder) (ma
 
 func StartControllers(controllers map[string]InitFunc, s *options.CMServer, rootClientBuilder, clientBuilder controller.ControllerClientBuilder, stop <-chan struct{}) error {
 	versionedClient := rootClientBuilder.ClientOrDie("shared-informers")
-	// TODO replace sharedInformers with newSharedInformers
-	sharedInformers := informers.NewSharedInformerFactory(versionedClient, nil, ResyncPeriod(s)())
-	newSharedInformers := newinformers.NewSharedInformerFactory(versionedClient, ResyncPeriod(s)())
+	sharedInformers := informers.NewSharedInformerFactory(versionedClient, ResyncPeriod(s)())
 
 	// always start the SA token controller first using a full-power client, since it needs to mint tokens for the rest
 	if len(s.ServiceAccountKeyFile) > 0 {
@@ -385,7 +377,6 @@ func StartControllers(controllers map[string]InitFunc, s *options.CMServer, root
 	ctx := ControllerContext{
 		ClientBuilder:      clientBuilder,
 		InformerFactory:    sharedInformers,
-		NewInformerFactory: newSharedInformers,
 		Options:            *s,
 		AvailableResources: availableResources,
 		Stop:               stop,
@@ -426,9 +417,9 @@ func StartControllers(controllers map[string]InitFunc, s *options.CMServer, root
 		glog.Warningf("Unsuccessful parsing of service CIDR %v: %v", s.ServiceCIDR, err)
 	}
 	nodeController, err := nodecontroller.NewNodeController(
-		newSharedInformers.Core().V1().Pods(),
-		newSharedInformers.Core().V1().Nodes(),
-		newSharedInformers.Extensions().V1beta1().DaemonSets(),
+		sharedInformers.Core().V1().Pods(),
+		sharedInformers.Core().V1().Nodes(),
+		sharedInformers.Extensions().V1beta1().DaemonSets(),
 		cloud,
 		clientBuilder.ClientOrDie("node-controller"),
 		s.PodEvictionTimeout.Duration,
@@ -455,8 +446,8 @@ func StartControllers(controllers map[string]InitFunc, s *options.CMServer, root
 	serviceController, err := servicecontroller.New(
 		cloud,
 		clientBuilder.ClientOrDie("service-controller"),
-		newSharedInformers.Core().V1().Services(),
-		newSharedInformers.Core().V1().Nodes(),
+		sharedInformers.Core().V1().Services(),
+		sharedInformers.Core().V1().Nodes(),
 		s.ClusterName,
 	)
 	if err != nil {
@@ -472,7 +463,7 @@ func StartControllers(controllers map[string]InitFunc, s *options.CMServer, root
 		} else if routes, ok := cloud.Routes(); !ok {
 			glog.Warning("configure-cloud-routes is set, but cloud provider does not support routes. Will not configure cloud provider routes.")
 		} else {
-			routeController := routecontroller.New(routes, clientBuilder.ClientOrDie("route-controller"), newSharedInformers.Core().V1().Nodes(), s.ClusterName, clusterCIDR)
+			routeController := routecontroller.New(routes, clientBuilder.ClientOrDie("route-controller"), sharedInformers.Core().V1().Nodes(), s.ClusterName, clusterCIDR)
 			go routeController.Run(stop, s.RouteReconciliationPeriod.Duration)
 			time.Sleep(wait.Jitter(s.ControllerStartInterval.Duration, ControllerStartJitter))
 		}
@@ -491,9 +482,9 @@ func StartControllers(controllers map[string]InitFunc, s *options.CMServer, root
 		VolumePlugins:             ProbeControllerVolumePlugins(cloud, s.VolumeConfiguration),
 		Cloud:                     cloud,
 		ClusterName:               s.ClusterName,
-		VolumeInformer:            newSharedInformers.Core().V1().PersistentVolumes(),
-		ClaimInformer:             newSharedInformers.Core().V1().PersistentVolumeClaims(),
-		ClassInformer:             newSharedInformers.Storage().V1beta1().StorageClasses(),
+		VolumeInformer:            sharedInformers.Core().V1().PersistentVolumes(),
+		ClaimInformer:             sharedInformers.Core().V1().PersistentVolumeClaims(),
+		ClassInformer:             sharedInformers.Storage().V1beta1().StorageClasses(),
 		EnableDynamicProvisioning: s.VolumeConfiguration.EnableDynamicProvisioning,
 	}
 	volumeController := persistentvolumecontroller.NewController(params)
@@ -507,10 +498,10 @@ func StartControllers(controllers map[string]InitFunc, s *options.CMServer, root
 	attachDetachController, attachDetachControllerErr :=
 		attachdetach.NewAttachDetachController(
 			clientBuilder.ClientOrDie("attachdetach-controller"),
-			newSharedInformers.Core().V1().Pods(),
-			newSharedInformers.Core().V1().Nodes(),
-			newSharedInformers.Core().V1().PersistentVolumeClaims(),
-			newSharedInformers.Core().V1().PersistentVolumes(),
+			sharedInformers.Core().V1().Pods(),
+			sharedInformers.Core().V1().Nodes(),
+			sharedInformers.Core().V1().PersistentVolumeClaims(),
+			sharedInformers.Core().V1().PersistentVolumes(),
 			cloud,
 			ProbeAttachableVolumePlugins(s.VolumeConfiguration),
 			s.DisableAttachDetachReconcilerSync,
@@ -522,9 +513,7 @@ func StartControllers(controllers map[string]InitFunc, s *options.CMServer, root
 	go attachDetachController.Run(stop)
 	time.Sleep(wait.Jitter(s.ControllerStartInterval.Duration, ControllerStartJitter))
 
-	// TODO replace sharedInformers with newSharedInformers
 	sharedInformers.Start(stop)
-	newSharedInformers.Start(stop)
 
 	select {}
 }

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

@@ -46,8 +46,8 @@ import (
 
 func startEndpointController(ctx ControllerContext) (bool, error) {
 	go endpointcontroller.NewEndpointController(
-		ctx.NewInformerFactory.Core().V1().Pods(),
-		ctx.NewInformerFactory.Core().V1().Services(),
+		ctx.InformerFactory.Core().V1().Pods(),
+		ctx.InformerFactory.Core().V1().Services(),
 		ctx.ClientBuilder.ClientOrDie("endpoint-controller"),
 	).Run(int(ctx.Options.ConcurrentEndpointSyncs), ctx.Stop)
 	return true, nil
@@ -55,8 +55,8 @@ func startEndpointController(ctx ControllerContext) (bool, error) {
 
 func startReplicationController(ctx ControllerContext) (bool, error) {
 	go replicationcontroller.NewReplicationManager(
-		ctx.NewInformerFactory.Core().V1().Pods(),
-		ctx.NewInformerFactory.Core().V1().ReplicationControllers(),
+		ctx.InformerFactory.Core().V1().Pods(),
+		ctx.InformerFactory.Core().V1().ReplicationControllers(),
 		ctx.ClientBuilder.ClientOrDie("replication-controller"),
 		replicationcontroller.BurstReplicas,
 		int(ctx.Options.LookupCacheSizeForRC),
@@ -67,7 +67,7 @@ func startReplicationController(ctx ControllerContext) (bool, error) {
 func startPodGCController(ctx ControllerContext) (bool, error) {
 	go podgc.NewPodGC(
 		ctx.ClientBuilder.ClientOrDie("pod-garbage-collector"),
-		ctx.NewInformerFactory.Core().V1().Pods(),
+		ctx.InformerFactory.Core().V1().Pods(),
 		int(ctx.Options.TerminatedPodGCThreshold),
 	).Run(ctx.Stop)
 	return true, nil
@@ -75,7 +75,7 @@ func startPodGCController(ctx ControllerContext) (bool, error) {
 
 func startResourceQuotaController(ctx ControllerContext) (bool, error) {
 	resourceQuotaControllerClient := ctx.ClientBuilder.ClientOrDie("resourcequota-controller")
-	resourceQuotaRegistry := quotainstall.NewRegistry(resourceQuotaControllerClient, ctx.NewInformerFactory)
+	resourceQuotaRegistry := quotainstall.NewRegistry(resourceQuotaControllerClient, ctx.InformerFactory)
 	groupKindsToReplenish := []schema.GroupKind{
 		api.Kind("Pod"),
 		api.Kind("Service"),
@@ -86,10 +86,10 @@ func startResourceQuotaController(ctx ControllerContext) (bool, error) {
 	}
 	resourceQuotaControllerOptions := &resourcequotacontroller.ResourceQuotaControllerOptions{
 		KubeClient:                resourceQuotaControllerClient,
-		ResourceQuotaInformer:     ctx.NewInformerFactory.Core().V1().ResourceQuotas(),
+		ResourceQuotaInformer:     ctx.InformerFactory.Core().V1().ResourceQuotas(),
 		ResyncPeriod:              controller.StaticResyncPeriodFunc(ctx.Options.ResourceQuotaSyncPeriod.Duration),
 		Registry:                  resourceQuotaRegistry,
-		ControllerFactory:         resourcequotacontroller.NewReplenishmentControllerFactory(ctx.NewInformerFactory),
+		ControllerFactory:         resourcequotacontroller.NewReplenishmentControllerFactory(ctx.InformerFactory),
 		ReplenishmentResyncPeriod: ResyncPeriod(&ctx.Options),
 		GroupKindsToReplenish:     groupKindsToReplenish,
 	}
@@ -130,7 +130,7 @@ func startNamespaceController(ctx ControllerContext) (bool, error) {
 		namespaceKubeClient,
 		namespaceClientPool,
 		discoverResourcesFn,
-		ctx.NewInformerFactory.Core().V1().Namespaces(),
+		ctx.InformerFactory.Core().V1().Namespaces(),
 		ctx.Options.NamespaceSyncPeriod.Duration,
 		v1.FinalizerKubernetes,
 	)
@@ -142,8 +142,8 @@ func startNamespaceController(ctx ControllerContext) (bool, error) {
 
 func startServiceAccountController(ctx ControllerContext) (bool, error) {
 	go serviceaccountcontroller.NewServiceAccountsController(
-		ctx.NewInformerFactory.Core().V1().ServiceAccounts(),
-		ctx.NewInformerFactory.Core().V1().Namespaces(),
+		ctx.InformerFactory.Core().V1().ServiceAccounts(),
+		ctx.InformerFactory.Core().V1().Namespaces(),
 		ctx.ClientBuilder.ClientOrDie("service-account-controller"),
 		serviceaccountcontroller.DefaultServiceAccountsControllerOptions(),
 	).Run(1, ctx.Stop)
@@ -152,7 +152,7 @@ func startServiceAccountController(ctx ControllerContext) (bool, error) {
 
 func startTTLController(ctx ControllerContext) (bool, error) {
 	go ttlcontroller.NewTTLController(
-		ctx.NewInformerFactory.Core().V1().Nodes(),
+		ctx.InformerFactory.Core().V1().Nodes(),
 		ctx.ClientBuilder.ClientOrDie("ttl-controller"),
 	).Run(5, ctx.Stop)
 	return true, nil

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

@@ -32,9 +32,9 @@ func startDaemonSetController(ctx ControllerContext) (bool, error) {
 		return false, nil
 	}
 	go daemon.NewDaemonSetsController(
-		ctx.NewInformerFactory.Extensions().V1beta1().DaemonSets(),
-		ctx.NewInformerFactory.Core().V1().Pods(),
-		ctx.NewInformerFactory.Core().V1().Nodes(),
+		ctx.InformerFactory.Extensions().V1beta1().DaemonSets(),
+		ctx.InformerFactory.Core().V1().Pods(),
+		ctx.InformerFactory.Core().V1().Nodes(),
 		ctx.ClientBuilder.ClientOrDie("daemon-set-controller"),
 		int(ctx.Options.LookupCacheSizeForDaemonSet),
 	).Run(int(ctx.Options.ConcurrentDaemonSetSyncs), ctx.Stop)
@@ -46,9 +46,9 @@ func startDeploymentController(ctx ControllerContext) (bool, error) {
 		return false, nil
 	}
 	go deployment.NewDeploymentController(
-		ctx.NewInformerFactory.Extensions().V1beta1().Deployments(),
-		ctx.NewInformerFactory.Extensions().V1beta1().ReplicaSets(),
-		ctx.NewInformerFactory.Core().V1().Pods(),
+		ctx.InformerFactory.Extensions().V1beta1().Deployments(),
+		ctx.InformerFactory.Extensions().V1beta1().ReplicaSets(),
+		ctx.InformerFactory.Core().V1().Pods(),
 		ctx.ClientBuilder.ClientOrDie("deployment-controller"),
 	).Run(int(ctx.Options.ConcurrentDeploymentSyncs), ctx.Stop)
 	return true, nil
@@ -59,8 +59,8 @@ func startReplicaSetController(ctx ControllerContext) (bool, error) {
 		return false, nil
 	}
 	go replicaset.NewReplicaSetController(
-		ctx.NewInformerFactory.Extensions().V1beta1().ReplicaSets(),
-		ctx.NewInformerFactory.Core().V1().Pods(),
+		ctx.InformerFactory.Extensions().V1beta1().ReplicaSets(),
+		ctx.InformerFactory.Core().V1().Pods(),
 		ctx.ClientBuilder.ClientOrDie("replicaset-controller"),
 		replicaset.BurstReplicas,
 		int(ctx.Options.LookupCacheSizeForRS),

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

@@ -30,12 +30,12 @@ func startDisruptionController(ctx ControllerContext) (bool, error) {
 		return false, nil
 	}
 	go disruption.NewDisruptionController(
-		ctx.NewInformerFactory.Core().V1().Pods(),
-		ctx.NewInformerFactory.Policy().V1beta1().PodDisruptionBudgets(),
-		ctx.NewInformerFactory.Core().V1().ReplicationControllers(),
-		ctx.NewInformerFactory.Extensions().V1beta1().ReplicaSets(),
-		ctx.NewInformerFactory.Extensions().V1beta1().Deployments(),
-		ctx.NewInformerFactory.Apps().V1beta1().StatefulSets(),
+		ctx.InformerFactory.Core().V1().Pods(),
+		ctx.InformerFactory.Policy().V1beta1().PodDisruptionBudgets(),
+		ctx.InformerFactory.Core().V1().ReplicationControllers(),
+		ctx.InformerFactory.Extensions().V1beta1().ReplicaSets(),
+		ctx.InformerFactory.Extensions().V1beta1().Deployments(),
+		ctx.InformerFactory.Apps().V1beta1().StatefulSets(),
 		ctx.ClientBuilder.ClientOrDie("disruption-controller"),
 	).Run(ctx.Stop)
 	return true, nil

hack/local-up-cluster.sh

@@ -575,6 +575,7 @@ function start_kubelet {
       fi
 
       sudo -E "${GO_OUT}/hyperkube" kubelet ${priv_arg}\
+        --enable-cri=false \
         --v=${LOG_LEVEL} \
         --chaos-chance="${CHAOS_CHANCE}" \
         --container-runtime="${CONTAINER_RUNTIME}" \

pkg/BUILD

@@ -40,7 +40,6 @@ filegroup(
         "//pkg/client/informers/informers_generated/externalversions:all-srcs",
         "//pkg/client/informers/informers_generated/internalversion:all-srcs",
         "//pkg/client/leaderelection:all-srcs",
-        "//pkg/client/legacylisters:all-srcs",
         "//pkg/client/listers/apps/internalversion:all-srcs",
         "//pkg/client/listers/apps/v1beta1:all-srcs",
         "//pkg/client/listers/authentication/internalversion:all-srcs",

pkg/client/legacylisters/BUILD

-package(default_visibility = ["//visibility:public"])
-
-licenses(["notice"])
-
-load(
-    "@io_bazel_rules_go//go:def.bzl",
-    "go_library",
-    "go_test",
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["listers_test.go"],
-    library = ":go_default_library",
-    tags = ["automanaged"],
-    deps = [
-        "//pkg/api/v1:go_default_library",
-        "//pkg/apis/extensions/v1beta1:go_default_library",
-        "//vendor:k8s.io/apimachinery/pkg/api/errors",
-        "//vendor:k8s.io/apimachinery/pkg/apis/meta/v1",
-        "//vendor:k8s.io/apimachinery/pkg/labels",
-        "//vendor:k8s.io/apimachinery/pkg/util/sets",
-        "//vendor:k8s.io/client-go/tools/cache",
-    ],
-)
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "listers.go",
-        "listers_core.go",
-        "listers_extensions.go",
-        "listers_rbac.go",
-    ],
-    tags = ["automanaged"],
-    deps = [
-        "//pkg/api:go_default_library",
-        "//pkg/api/v1:go_default_library",
-        "//pkg/apis/apps/v1beta1:go_default_library",
-        "//pkg/apis/certificates/v1beta1:go_default_library",
-        "//pkg/apis/extensions:go_default_library",
-        "//pkg/apis/extensions/v1beta1:go_default_library",
-        "//pkg/apis/policy/v1beta1:go_default_library",
-        "//pkg/apis/rbac:go_default_library",
-        "//pkg/apis/storage:go_default_library",
-        "//pkg/apis/storage/v1beta1:go_default_library",
-        "//vendor:github.com/golang/glog",
-        "//vendor:k8s.io/apimachinery/pkg/api/errors",
-        "//vendor:k8s.io/apimachinery/pkg/apis/meta/v1",
-        "//vendor:k8s.io/apimachinery/pkg/labels",
-        "//vendor:k8s.io/client-go/tools/cache",
-    ],
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [":package-srcs"],
-    tags = ["automanaged"],
-)

pkg/client/legacylisters/listers_extensions.go

-/*
-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 listers
-
-import (
-	"fmt"
-
-	"k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/client-go/tools/cache"
-	"k8s.io/kubernetes/pkg/api/v1"
-	extensionsinternal "k8s.io/kubernetes/pkg/apis/extensions"
-	extensions "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
-)
-
-//  TODO: generate these classes and methods for all resources of interest using
-// a script.  Can use "go generate" once 1.4 is supported by all users.
-
-// Lister makes an Index have the List method.  The Stores must contain only the expected type
-// Example:
-// s := cache.NewStore()
-// lw := cache.ListWatch{Client: c, FieldSelector: sel, Resource: "pods"}
-// r := cache.NewReflector(lw, &extensions.Deployment{}, s).Run()
-// l := StoreToDeploymentLister{s}
-// l.List()
-
-// StoreToDeploymentLister helps list deployments
-type StoreToDeploymentLister struct {
-	Indexer cache.Indexer
-}
-
-func (s *StoreToDeploymentLister) List(selector labels.Selector) (ret []*extensions.Deployment, err error) {
-	err = cache.ListAll(s.Indexer, selector, func(m interface{}) {
-		ret = append(ret, m.(*extensions.Deployment))
-	})
-	return ret, err
-}
-
-func (s *StoreToDeploymentLister) Deployments(namespace string) storeDeploymentsNamespacer {
-	return storeDeploymentsNamespacer{Indexer: s.Indexer, namespace: namespace}
-}
-
-type storeDeploymentsNamespacer struct {
-	Indexer   cache.Indexer
-	namespace string
-}
-
-func (s storeDeploymentsNamespacer) List(selector labels.Selector) (ret []*extensions.Deployment, err error) {
-	err = cache.ListAllByNamespace(s.Indexer, s.namespace, selector, func(m interface{}) {
-		ret = append(ret, m.(*extensions.Deployment))
-	})
-	return ret, err
-}
-
-func (s storeDeploymentsNamespacer) Get(name string) (*extensions.Deployment, error) {
-	obj, exists, err := s.Indexer.GetByKey(s.namespace + "/" + name)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, errors.NewNotFound(extensionsinternal.Resource("deployment"), name)
-	}
-	return obj.(*extensions.Deployment), nil
-}
-
-// GetDeploymentsForReplicaSet returns a list of deployments managing a replica set. Returns an error only if no matching deployments are found.
-func (s *StoreToDeploymentLister) GetDeploymentsForReplicaSet(rs *extensions.ReplicaSet) (deployments []*extensions.Deployment, err error) {
-	if len(rs.Labels) == 0 {
-		err = fmt.Errorf("no deployments found for ReplicaSet %v because it has no labels", rs.Name)
-		return
-	}
-
-	// TODO: MODIFY THIS METHOD so that it checks for the podTemplateSpecHash label
-	dList, err := s.Deployments(rs.Namespace).List(labels.Everything())
-	if err != nil {
-		return
-	}
-	for _, d := range dList {
-		selector, err := metav1.LabelSelectorAsSelector(d.Spec.Selector)
-		if err != nil {
-			return nil, fmt.Errorf("invalid label selector: %v", err)
-		}
-		// If a deployment with a nil or empty selector creeps in, it should match nothing, not everything.
-		if selector.Empty() || !selector.Matches(labels.Set(rs.Labels)) {
-			continue
-		}
-		deployments = append(deployments, d)
-	}
-	if len(deployments) == 0 {
-		err = fmt.Errorf("could not find deployments set for ReplicaSet %s in namespace %s with labels: %v", rs.Name, rs.Namespace, rs.Labels)
-	}
-	return
-}
-
-// GetDeploymentsForDeployments returns a list of deployments managing a pod. Returns an error only if no matching deployments are found.
-// TODO eliminate shallow copies
-func (s *StoreToDeploymentLister) GetDeploymentsForPod(pod *v1.Pod) (deployments []*extensions.Deployment, err error) {
-	if len(pod.Labels) == 0 {
-		err = fmt.Errorf("no deployments found for Pod %v because it has no labels", pod.Name)
-		return
-	}
-
-	if len(pod.Labels[extensions.DefaultDeploymentUniqueLabelKey]) == 0 {
-		return
-	}
-
-	dList, err := s.Deployments(pod.Namespace).List(labels.Everything())
-	if err != nil {
-		return
-	}
-	for _, d := range dList {
-		selector, err := metav1.LabelSelectorAsSelector(d.Spec.Selector)
-		if err != nil {
-			return nil, fmt.Errorf("invalid label selector: %v", err)
-		}
-		// If a deployment with a nil or empty selector creeps in, it should match nothing, not everything.
-		if selector.Empty() || !selector.Matches(labels.Set(pod.Labels)) {
-			continue
-		}
-		deployments = append(deployments, d)
-	}
-	if len(deployments) == 0 {
-		err = fmt.Errorf("could not find deployments set for Pod %s in namespace %s with labels: %v", pod.Name, pod.Namespace, pod.Labels)
-	}
-	return
-}
-
-// StoreToReplicaSetLister helps list replicasets
-type StoreToReplicaSetLister struct {
-	Indexer cache.Indexer
-}
-
-func (s *StoreToReplicaSetLister) List(selector labels.Selector) (ret []*extensions.ReplicaSet, err error) {
-	err = cache.ListAll(s.Indexer, selector, func(m interface{}) {
-		ret = append(ret, m.(*extensions.ReplicaSet))
-	})
-	return ret, err
-}
-
-func (s *StoreToReplicaSetLister) ReplicaSets(namespace string) storeReplicaSetsNamespacer {
-	return storeReplicaSetsNamespacer{Indexer: s.Indexer, namespace: namespace}
-}
-
-type storeReplicaSetsNamespacer struct {
-	Indexer   cache.Indexer
-	namespace string
-}
-
-func (s storeReplicaSetsNamespacer) List(selector labels.Selector) (ret []*extensions.ReplicaSet, err error) {
-	err = cache.ListAllByNamespace(s.Indexer, s.namespace, selector, func(m interface{}) {
-		ret = append(ret, m.(*extensions.ReplicaSet))
-	})
-	return ret, err
-}
-
-func (s storeReplicaSetsNamespacer) Get(name string) (*extensions.ReplicaSet, error) {
-	obj, exists, err := s.Indexer.GetByKey(s.namespace + "/" + name)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, errors.NewNotFound(extensionsinternal.Resource("replicaset"), name)
-	}
-	return obj.(*extensions.ReplicaSet), nil
-}
-
-// GetPodReplicaSets returns a list of ReplicaSets managing a pod. Returns an error only if no matching ReplicaSets are found.
-func (s *StoreToReplicaSetLister) GetPodReplicaSets(pod *v1.Pod) (rss []*extensions.ReplicaSet, err error) {
-	if len(pod.Labels) == 0 {
-		err = fmt.Errorf("no ReplicaSets found for pod %v because it has no labels", pod.Name)
-		return
-	}
-
-	list, err := s.ReplicaSets(pod.Namespace).List(labels.Everything())
-	if err != nil {
-		return
-	}
-	for _, rs := range list {
-		if rs.Namespace != pod.Namespace {
-			continue
-		}
-		selector, err := metav1.LabelSelectorAsSelector(rs.Spec.Selector)
-		if err != nil {
-			return nil, fmt.Errorf("invalid selector: %v", err)
-		}
-
-		// If a ReplicaSet with a nil or empty selector creeps in, it should match nothing, not everything.
-		if selector.Empty() || !selector.Matches(labels.Set(pod.Labels)) {
-			continue
-		}
-		rss = append(rss, rs)
-	}
-	if len(rss) == 0 {
-		err = fmt.Errorf("could not find ReplicaSet for pod %s in namespace %s with labels: %v", pod.Name, pod.Namespace, pod.Labels)
-	}
-	return
-}

pkg/client/legacylisters/listers_rbac.go

-/*
-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 listers
-
-import (
-	"k8s.io/apimachinery/pkg/api/errors"
-	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/client-go/tools/cache"
-	rbac "k8s.io/kubernetes/pkg/apis/rbac"
-)
-
-//  TODO: generate these classes and methods for all resources of interest using
-// a script.  Can use "go generate" once 1.4 is supported by all users.
-
-// Lister makes an Index have the List method.  The Stores must contain only the expected type
-// Example:
-// s := cache.NewStore()
-// lw := cache.ListWatch{Client: c, FieldSelector: sel, Resource: "pods"}
-// r := cache.NewReflector(lw, &rbac.ClusterRole{}, s).Run()
-// l := clusterRoleLister{s}
-// l.List()
-
-func NewClusterRoleLister(indexer cache.Indexer) ClusterRoleLister {
-	return &clusterRoleLister{indexer: indexer}
-}
-func NewClusterRoleBindingLister(indexer cache.Indexer) ClusterRoleBindingLister {
-	return &clusterRoleBindingLister{indexer: indexer}
-}
-func NewRoleLister(indexer cache.Indexer) RoleLister {
-	return &roleLister{indexer: indexer}
-}
-func NewRoleBindingLister(indexer cache.Indexer) RoleBindingLister {
-	return &roleBindingLister{indexer: indexer}
-}
-
-// these interfaces are used by the rbac authorizer
-type authorizerClusterRoleGetter interface {
-	GetClusterRole(name string) (*rbac.ClusterRole, error)
-}
-
-type authorizerClusterRoleBindingLister interface {
-	ListClusterRoleBindings() ([]*rbac.ClusterRoleBinding, error)
-}
-
-type authorizerRoleGetter interface {
-	GetRole(namespace, name string) (*rbac.Role, error)
-}
-
-type authorizerRoleBindingLister interface {
-	ListRoleBindings(namespace string) ([]*rbac.RoleBinding, error)
-}
-
-type ClusterRoleLister interface {
-	authorizerClusterRoleGetter
-	List(selector labels.Selector) (ret []*rbac.ClusterRole, err error)
-	Get(name string) (*rbac.ClusterRole, error)
-}
-
-type clusterRoleLister struct {
-	indexer cache.Indexer
-}
-
-func (s *clusterRoleLister) List(selector labels.Selector) (ret []*rbac.ClusterRole, err error) {
-	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
-		ret = append(ret, m.(*rbac.ClusterRole))
-	})
-	return ret, err
-}
-
-func (s clusterRoleLister) Get(name string) (*rbac.ClusterRole, error) {
-	obj, exists, err := s.indexer.GetByKey(name)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, errors.NewNotFound(rbac.Resource("clusterrole"), name)
-	}
-	return obj.(*rbac.ClusterRole), nil
-}
-
-func (s clusterRoleLister) GetClusterRole(name string) (*rbac.ClusterRole, error) {
-	return s.Get(name)
-}
-
-type ClusterRoleBindingLister interface {
-	authorizerClusterRoleBindingLister
-	List(selector labels.Selector) (ret []*rbac.ClusterRoleBinding, err error)
-	Get(name string) (*rbac.ClusterRoleBinding, error)
-}
-
-type clusterRoleBindingLister struct {
-	indexer cache.Indexer
-}
-
-func (s *clusterRoleBindingLister) List(selector labels.Selector) (ret []*rbac.ClusterRoleBinding, err error) {
-	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
-		ret = append(ret, m.(*rbac.ClusterRoleBinding))
-	})
-	return ret, err
-}
-
-func (s clusterRoleBindingLister) Get(name string) (*rbac.ClusterRoleBinding, error) {
-	obj, exists, err := s.indexer.GetByKey(name)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, errors.NewNotFound(rbac.Resource("clusterrolebinding"), name)
-	}
-	return obj.(*rbac.ClusterRoleBinding), nil
-}
-
-func (s clusterRoleBindingLister) ListClusterRoleBindings() ([]*rbac.ClusterRoleBinding, error) {
-	return s.List(labels.Everything())
-}
-
-type RoleLister interface {
-	authorizerRoleGetter
-	List(selector labels.Selector) (ret []*rbac.Role, err error)
-	Roles(namespace string) RoleNamespaceLister
-}
-
-type RoleNamespaceLister interface {
-	List(selector labels.Selector) (ret []*rbac.Role, err error)
-	Get(name string) (*rbac.Role, error)
-}
-
-type roleLister struct {
-	indexer cache.Indexer
-}
-
-func (s *roleLister) List(selector labels.Selector) (ret []*rbac.Role, err error) {
-	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
-		ret = append(ret, m.(*rbac.Role))
-	})
-	return ret, err
-}
-
-func (s *roleLister) Roles(namespace string) RoleNamespaceLister {
-	return roleNamespaceLister{indexer: s.indexer, namespace: namespace}
-}
-
-func (s roleLister) GetRole(namespace, name string) (*rbac.Role, error) {
-	return s.Roles(namespace).Get(name)
-}
-
-type roleNamespaceLister struct {
-	indexer   cache.Indexer
-	namespace string
-}
-
-func (s roleNamespaceLister) List(selector labels.Selector) (ret []*rbac.Role, err error) {
-	err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
-		ret = append(ret, m.(*rbac.Role))
-	})
-	return ret, err
-}
-
-func (s roleNamespaceLister) Get(name string) (*rbac.Role, error) {
-	obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, errors.NewNotFound(rbac.Resource("role"), name)
-	}
-	return obj.(*rbac.Role), nil
-}
-
-type RoleBindingLister interface {
-	authorizerRoleBindingLister
-	List(selector labels.Selector) (ret []*rbac.RoleBinding, err error)
-	RoleBindings(namespace string) RoleBindingNamespaceLister
-}
-
-type RoleBindingNamespaceLister interface {
-	List(selector labels.Selector) (ret []*rbac.RoleBinding, err error)
-	Get(name string) (*rbac.RoleBinding, error)
-}
-
-type roleBindingLister struct {
-	indexer cache.Indexer
-}
-
-func (s *roleBindingLister) List(selector labels.Selector) (ret []*rbac.RoleBinding, err error) {
-	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
-		ret = append(ret, m.(*rbac.RoleBinding))
-	})
-	return ret, err
-}
-
-func (s *roleBindingLister) RoleBindings(namespace string) RoleBindingNamespaceLister {
-	return roleBindingNamespaceLister{indexer: s.indexer, namespace: namespace}
-}
-
-func (s roleBindingLister) ListRoleBindings(namespace string) ([]*rbac.RoleBinding, error) {
-	return s.RoleBindings(namespace).List(labels.Everything())
-}
-
-type roleBindingNamespaceLister struct {
-	indexer   cache.Indexer
-	namespace string
-}
-
-func (s roleBindingNamespaceLister) List(selector labels.Selector) (ret []*rbac.RoleBinding, err error) {
-	err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
-		ret = append(ret, m.(*rbac.RoleBinding))
-	})
-	return ret, err
-}
-
-func (s roleBindingNamespaceLister) Get(name string) (*rbac.RoleBinding, error) {
-	obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, errors.NewNotFound(rbac.Resource("rolebinding"), name)
-	}
-	return obj.(*rbac.RoleBinding), nil
-}

pkg/controller/BUILD

@@ -100,7 +100,6 @@ filegroup(
         "//pkg/controller/disruption:all-srcs",
         "//pkg/controller/endpoint:all-srcs",
         "//pkg/controller/garbagecollector:all-srcs",
-        "//pkg/controller/informers:all-srcs",
         "//pkg/controller/job:all-srcs",
         "//pkg/controller/namespace:all-srcs",
         "//pkg/controller/node:all-srcs",

pkg/controller/informers/BUILD

-package(default_visibility = ["//visibility:public"])
-
-licenses(["notice"])
-
-load(
-    "@io_bazel_rules_go//go:def.bzl",
-    "go_library",
-)
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "batch.go",
-        "core.go",
-        "extensions.go",
-        "factory.go",
-        "generic.go",
-        "rbac.go",
-        "storage.go",
-    ],
-    tags = ["automanaged"],
-    deps = [
-        "//pkg/api:go_default_library",
-        "//pkg/api/v1:go_default_library",
-        "//pkg/apis/batch:go_default_library",
-        "//pkg/apis/batch/v1:go_default_library",
-        "//pkg/apis/extensions:go_default_library",
-        "//pkg/apis/extensions/v1beta1:go_default_library",
-        "//pkg/apis/rbac:go_default_library",
-        "//pkg/apis/storage/v1beta1:go_default_library",
-        "//pkg/client/clientset_generated/clientset:go_default_library",
-        "//pkg/client/clientset_generated/internalclientset:go_default_library",
-        "//pkg/client/legacylisters:go_default_library",
-        "//pkg/client/listers/batch/v1:go_default_library",
-        "//pkg/client/listers/core/internalversion:go_default_library",
-        "//vendor:github.com/golang/glog",
-        "//vendor:k8s.io/apimachinery/pkg/apis/meta/v1",
-        "//vendor:k8s.io/apimachinery/pkg/runtime",
-        "//vendor:k8s.io/apimachinery/pkg/runtime/schema",
-        "//vendor:k8s.io/apimachinery/pkg/watch",
-        "//vendor:k8s.io/client-go/tools/cache",
-    ],
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [":package-srcs"],
-    tags = ["automanaged"],
-)

pkg/controller/informers/OWNERS

-reviewers:
-- derekwaynecarr
-- caesarxuchao
-- wojtek-t
-- lavalamp
-- deads2k

pkg/controller/informers/batch.go

-/*
-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 informers
-
-import (
-	"reflect"
-	"time"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/watch"
-	"k8s.io/client-go/tools/cache"
-	batch "k8s.io/kubernetes/pkg/apis/batch/v1"
-	"k8s.io/kubernetes/pkg/client/clientset_generated/clientset"
-	batchv1listers "k8s.io/kubernetes/pkg/client/listers/batch/v1"
-)
-
-// JobInformer is type of SharedIndexInformer which watches and lists all jobs.
-// Interface provides constructor for informer and lister for jobs
-type JobInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() batchv1listers.JobLister
-}
-
-type jobInformer struct {
-	*sharedInformerFactory
-}
-
-// Informer checks whether jobInformer exists in sharedInformerFactory and if not, it creates new informer of type
-// jobInformer and connects it to sharedInformerFactory
-func (f *jobInformer) Informer() cache.SharedIndexInformer {
-	f.lock.Lock()
-	defer f.lock.Unlock()
-
-	informerType := reflect.TypeOf(&batch.Job{})
-	informer, exists := f.informers[informerType]
-	if exists {
-		return informer
-	}
-	informer = NewJobInformer(f.client, f.defaultResync)
-	f.informers[informerType] = informer
-
-	return informer
-}
-
-// NewJobInformer returns a SharedIndexInformer that lists and watches all jobs
-func NewJobInformer(client clientset.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
-				return client.Batch().Jobs(metav1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
-				return client.Batch().Jobs(metav1.NamespaceAll).Watch(options)
-			},
-		},
-		&batch.Job{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-// Lister returns lister for jobInformer
-func (f *jobInformer) Lister() batchv1listers.JobLister {
-	informer := f.Informer()
-	return batchv1listers.NewJobLister(informer.GetIndexer())
-}

pkg/controller/informers/extensions.go

-/*
-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 informers
-
-import (
-	"reflect"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/watch"
-	"k8s.io/client-go/tools/cache"
-	extensions "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
-	"k8s.io/kubernetes/pkg/client/legacylisters"
-)
-
-// DaemonSetInformer is type of SharedIndexInformer which watches and lists all pods.
-// Interface provides constructor for informer and lister for pods
-type DaemonSetInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() *listers.StoreToDaemonSetLister
-}
-
-type daemonSetInformer struct {
-	*sharedInformerFactory
-}
-
-func (f *daemonSetInformer) Informer() cache.SharedIndexInformer {
-	f.lock.Lock()
-	defer f.lock.Unlock()
-
-	informerType := reflect.TypeOf(&extensions.DaemonSet{})
-	informer, exists := f.informers[informerType]
-	if exists {
-		return informer
-	}
-	informer = cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
-				return f.client.Extensions().DaemonSets(metav1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
-				return f.client.Extensions().DaemonSets(metav1.NamespaceAll).Watch(options)
-			},
-		},
-		&extensions.DaemonSet{},
-		f.defaultResync,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-	f.informers[informerType] = informer
-
-	return informer
-}
-
-func (f *daemonSetInformer) Lister() *listers.StoreToDaemonSetLister {
-	informer := f.Informer()
-	return &listers.StoreToDaemonSetLister{Store: informer.GetIndexer()}
-}
-
-// DeploymentInformer is a type of SharedIndexInformer which watches and lists all deployments.
-type DeploymentInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() *listers.StoreToDeploymentLister
-}
-
-type deploymentInformer struct {
-	*sharedInformerFactory
-}
-
-func (f *deploymentInformer) Informer() cache.SharedIndexInformer {
-	f.lock.Lock()
-	defer f.lock.Unlock()
-
-	informerType := reflect.TypeOf(&extensions.Deployment{})
-	informer, exists := f.informers[informerType]
-	if exists {
-		return informer
-	}
-	informer = cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
-				return f.client.Extensions().Deployments(metav1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
-				return f.client.Extensions().Deployments(metav1.NamespaceAll).Watch(options)
-			},
-		},
-		&extensions.Deployment{},
-		f.defaultResync,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-	f.informers[informerType] = informer
-
-	return informer
-}
-
-func (f *deploymentInformer) Lister() *listers.StoreToDeploymentLister {
-	informer := f.Informer()
-	return &listers.StoreToDeploymentLister{Indexer: informer.GetIndexer()}
-}
-
-// ReplicaSetInformer is a type of SharedIndexInformer which watches and lists all replicasets.
-type ReplicaSetInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() *listers.StoreToReplicaSetLister
-}
-
-type replicaSetInformer struct {
-	*sharedInformerFactory
-}
-
-func (f *replicaSetInformer) Informer() cache.SharedIndexInformer {
-	f.lock.Lock()
-	defer f.lock.Unlock()
-
-	informerType := reflect.TypeOf(&extensions.ReplicaSet{})
-	informer, exists := f.informers[informerType]
-	if exists {
-		return informer
-	}
-	informer = cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
-				return f.client.Extensions().ReplicaSets(metav1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
-				return f.client.Extensions().ReplicaSets(metav1.NamespaceAll).Watch(options)
-			},
-		},
-		&extensions.ReplicaSet{},
-		f.defaultResync,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-	f.informers[informerType] = informer
-
-	return informer
-}
-
-func (f *replicaSetInformer) Lister() *listers.StoreToReplicaSetLister {
-	informer := f.Informer()
-	return &listers.StoreToReplicaSetLister{Indexer: informer.GetIndexer()}
-}

pkg/controller/informers/factory.go

-/*
-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.
-*/
-
-package informers
-
-import (
-	"reflect"
-	"sync"
-	"time"
-
-	"github.com/golang/glog"
-
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/client-go/tools/cache"
-	"k8s.io/kubernetes/pkg/client/clientset_generated/clientset"
-	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
-)
-
-// SharedInformerFactory provides interface which holds unique informers for pods, nodes, namespaces, persistent volume
-// claims and persistent volumes
-type SharedInformerFactory interface {
-	// Start starts informers that can start AFTER the API server and controllers have started
-	Start(stopCh <-chan struct{})
-
-	ForResource(schema.GroupResource) (GenericInformer, error)
-
-	// when you update these, update generic.go/ForResource, same package
-
-	Pods() PodInformer
-	LimitRanges() LimitRangeInformer
-	InternalLimitRanges() InternalLimitRangeInformer
-	Namespaces() NamespaceInformer
-	InternalNamespaces() InternalNamespaceInformer
-	Nodes() NodeInformer
-	PersistentVolumeClaims() PVCInformer
-	PersistentVolumes() PVInformer
-	ServiceAccounts() ServiceAccountInformer
-
-	DaemonSets() DaemonSetInformer
-	Deployments() DeploymentInformer
-	ReplicaSets() ReplicaSetInformer
-	ReplicationControllers() ReplicationControllerInformer
-
-	ClusterRoleBindings() ClusterRoleBindingInformer
-	ClusterRoles() ClusterRoleInformer
-	RoleBindings() RoleBindingInformer
-	Roles() RoleInformer
-
-	StorageClasses() StorageClassInformer
-
-	Jobs() JobInformer
-}
-
-type sharedInformerFactory struct {
-	client clientset.Interface
-	// for admission plugins etc.
-	internalclient internalclientset.Interface
-	lock           sync.Mutex
-	defaultResync  time.Duration
-
-	informers map[reflect.Type]cache.SharedIndexInformer
-	// startedInformers is used for tracking which informers have been started
-	// this allows calling of Start method multiple times
-	startedInformers map[reflect.Type]bool
-}
-
-// NewSharedInformerFactory constructs a new instance of sharedInformerFactory
-func NewSharedInformerFactory(client clientset.Interface, internalclient internalclientset.Interface, defaultResync time.Duration) SharedInformerFactory {
-	return &sharedInformerFactory{
-		client:           client,
-		internalclient:   internalclient,
-		defaultResync:    defaultResync,
-		informers:        make(map[reflect.Type]cache.SharedIndexInformer),
-		startedInformers: make(map[reflect.Type]bool),
-	}
-}
-
-// Start initializes all requested informers.
-func (f *sharedInformerFactory) Start(stopCh <-chan struct{}) {
-	f.lock.Lock()
-	defer f.lock.Unlock()
-
-	glog.V(1).Infoln("Starting informer factory")
-
-	for informerType, informer := range f.informers {
-		if !f.startedInformers[informerType] {
-			glog.V(2).Infof("Starting informer for %v", informerType)
-			go informer.Run(stopCh)
-			f.startedInformers[informerType] = true
-		}
-	}
-}
-
-// Pods returns a SharedIndexInformer that lists and watches all pods
-func (f *sharedInformerFactory) Pods() PodInformer {
-	return &podInformer{sharedInformerFactory: f}
-}
-
-// Nodes returns a SharedIndexInformer that lists and watches all nodes
-func (f *sharedInformerFactory) Nodes() NodeInformer {
-	return &nodeInformer{sharedInformerFactory: f}
-}
-
-// Namespaces returns a SharedIndexInformer that lists and watches all namespaces
-func (f *sharedInformerFactory) Namespaces() NamespaceInformer {
-	return &namespaceInformer{sharedInformerFactory: f}
-}
-
-// InternalNamespaces returns a SharedIndexInformer that lists and watches all namespaces
-func (f *sharedInformerFactory) InternalNamespaces() InternalNamespaceInformer {
-	return &internalNamespaceInformer{sharedInformerFactory: f}
-}
-
-// PersistentVolumeClaims returns a SharedIndexInformer that lists and watches all persistent volume claims
-func (f *sharedInformerFactory) PersistentVolumeClaims() PVCInformer {
-	return &pvcInformer{sharedInformerFactory: f}
-}
-
-// PersistentVolumes returns a SharedIndexInformer that lists and watches all persistent volumes
-func (f *sharedInformerFactory) PersistentVolumes() PVInformer {
-	return &pvInformer{sharedInformerFactory: f}
-}
-
-// ServiceAccounts returns a SharedIndexInformer that lists and watches all service accounts.
-func (f *sharedInformerFactory) ServiceAccounts() ServiceAccountInformer {
-	return &serviceAccountInformer{sharedInformerFactory: f}
-}
-
-// DaemonSets returns a SharedIndexInformer that lists and watches all daemon sets.
-func (f *sharedInformerFactory) DaemonSets() DaemonSetInformer {
-	return &daemonSetInformer{sharedInformerFactory: f}
-}
-
-func (f *sharedInformerFactory) Deployments() DeploymentInformer {
-	return &deploymentInformer{sharedInformerFactory: f}
-}
-
-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}
-}
-
-func (f *sharedInformerFactory) ClusterRoleBindings() ClusterRoleBindingInformer {
-	return &clusterRoleBindingInformer{sharedInformerFactory: f}
-}
-
-func (f *sharedInformerFactory) Roles() RoleInformer {
-	return &roleInformer{sharedInformerFactory: f}
-}
-
-func (f *sharedInformerFactory) RoleBindings() RoleBindingInformer {
-	return &roleBindingInformer{sharedInformerFactory: f}
-}
-
-// LimitRanges returns a SharedIndexInformer that lists and watches all limit ranges.
-func (f *sharedInformerFactory) LimitRanges() LimitRangeInformer {
-	return &limitRangeInformer{sharedInformerFactory: f}
-}
-
-// InternalLimitRanges returns a SharedIndexInformer that lists and watches all limit ranges.
-func (f *sharedInformerFactory) InternalLimitRanges() InternalLimitRangeInformer {
-	return &internalLimitRangeInformer{sharedInformerFactory: f}
-}
-
-// StorageClasses returns a SharedIndexInformer that lists and watches all storage classes
-func (f *sharedInformerFactory) StorageClasses() StorageClassInformer {
-	return &storageClassInformer{sharedInformerFactory: f}
-}
-
-// Jobs returns a SharedIndexInformer that lists and watches all storage jobs
-func (f *sharedInformerFactory) Jobs() JobInformer {
-	return &jobInformer{sharedInformerFactory: f}
-}

pkg/controller/informers/generic.go

-/*
-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 informers
-
-import (
-	"fmt"
-
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/client-go/tools/cache"
-	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/apis/batch"
-	extensionsinternal "k8s.io/kubernetes/pkg/apis/extensions"
-	rbacinternal "k8s.io/kubernetes/pkg/apis/rbac"
-)
-
-// GenericInformer is type of SharedIndexInformer which will locate and delegate to other
-// sharedInformers based on type
-type GenericInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() cache.GenericLister
-}
-
-// ForResource gives generic access to a shared informer of the matching type
-// TODO extend this to unknown resources with a client pool
-func (f *sharedInformerFactory) ForResource(resource schema.GroupResource) (GenericInformer, error) {
-	switch resource {
-	case api.Resource("pods"):
-		return &genericInformer{resource: resource, informer: f.Pods().Informer()}, nil
-	case api.Resource("limitranges"):
-		return &genericInformer{resource: resource, informer: f.LimitRanges().Informer()}, nil
-	case api.Resource("namespaces"):
-		return &genericInformer{resource: resource, informer: f.Namespaces().Informer()}, nil
-	case api.Resource("nodes"):
-		return &genericInformer{resource: resource, informer: f.Nodes().Informer()}, nil
-	case api.Resource("persistentvolumeclaims"):
-		return &genericInformer{resource: resource, informer: f.PersistentVolumeClaims().Informer()}, nil
-	case api.Resource("persistentvolumes"):
-		return &genericInformer{resource: resource, informer: f.PersistentVolumes().Informer()}, nil
-	case api.Resource("serviceaccounts"):
-		return &genericInformer{resource: resource, informer: f.ServiceAccounts().Informer()}, nil
-
-	case extensionsinternal.Resource("daemonsets"):
-		return &genericInformer{resource: resource, informer: f.DaemonSets().Informer()}, nil
-	case extensionsinternal.Resource("deployments"):
-		return &genericInformer{resource: resource, informer: f.Deployments().Informer()}, nil
-	case extensionsinternal.Resource("replicasets"):
-		return &genericInformer{resource: resource, informer: f.ReplicaSets().Informer()}, nil
-
-	case rbacinternal.Resource("clusterrolebindings"):
-		return &genericInformer{resource: resource, informer: f.ClusterRoleBindings().Informer()}, nil
-	case rbacinternal.Resource("clusterroles"):
-		return &genericInformer{resource: resource, informer: f.ClusterRoles().Informer()}, nil
-	case rbacinternal.Resource("rolebindings"):
-		return &genericInformer{resource: resource, informer: f.RoleBindings().Informer()}, nil
-	case rbacinternal.Resource("roles"):
-		return &genericInformer{resource: resource, informer: f.Roles().Informer()}, nil
-
-	case batch.Resource("jobs"):
-		return &genericInformer{resource: resource, informer: f.Jobs().Informer()}, nil
-	}
-
-	return nil, fmt.Errorf("no informer found for %v", resource)
-}
-
-type genericInformer struct {
-	informer cache.SharedIndexInformer
-	resource schema.GroupResource
-}
-
-func (f *genericInformer) Informer() cache.SharedIndexInformer {
-	return f.informer
-}
-
-func (f *genericInformer) Lister() cache.GenericLister {
-	return cache.NewGenericLister(f.Informer().GetIndexer(), f.resource)
-}

pkg/controller/informers/rbac.go

-/*
-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 informers
-
-import (
-	"reflect"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/watch"
-	"k8s.io/client-go/tools/cache"
-	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/apis/rbac"
-	"k8s.io/kubernetes/pkg/client/legacylisters"
-)
-
-type ClusterRoleInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() listers.ClusterRoleLister
-}
-
-type clusterRoleInformer struct {
-	*sharedInformerFactory
-}
-
-func (f *clusterRoleInformer) Informer() cache.SharedIndexInformer {
-	f.lock.Lock()
-	defer f.lock.Unlock()
-
-	informerType := reflect.TypeOf(&rbac.ClusterRole{})
-	informer, exists := f.informers[informerType]
-	if exists {
-		return informer
-	}
-	informer = cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
-				return f.internalclient.Rbac().ClusterRoles().List(convertListOptionsOrDie(options))
-			},
-			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
-				return f.internalclient.Rbac().ClusterRoles().Watch(convertListOptionsOrDie(options))
-			},
-		},
-		&rbac.ClusterRole{},
-		f.defaultResync,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-	f.informers[informerType] = informer
-
-	return informer
-}
-
-func (f *clusterRoleInformer) Lister() listers.ClusterRoleLister {
-	return listers.NewClusterRoleLister(f.Informer().GetIndexer())
-}
-
-type ClusterRoleBindingInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() listers.ClusterRoleBindingLister
-}
-
-type clusterRoleBindingInformer struct {
-	*sharedInformerFactory
-}
-
-func (f *clusterRoleBindingInformer) Informer() cache.SharedIndexInformer {
-	f.lock.Lock()
-	defer f.lock.Unlock()
-
-	informerType := reflect.TypeOf(&rbac.ClusterRoleBinding{})
-	informer, exists := f.informers[informerType]
-	if exists {
-		return informer
-	}
-	informer = cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
-				return f.internalclient.Rbac().ClusterRoleBindings().List(convertListOptionsOrDie(options))
-			},
-			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
-				return f.internalclient.Rbac().ClusterRoleBindings().Watch(convertListOptionsOrDie(options))
-			},
-		},
-		&rbac.ClusterRoleBinding{},
-		f.defaultResync,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-	f.informers[informerType] = informer
-
-	return informer
-}
-
-func (f *clusterRoleBindingInformer) Lister() listers.ClusterRoleBindingLister {
-	return listers.NewClusterRoleBindingLister(f.Informer().GetIndexer())
-}
-
-type RoleInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() listers.RoleLister
-}
-
-type roleInformer struct {
-	*sharedInformerFactory
-}
-
-func (f *roleInformer) Informer() cache.SharedIndexInformer {
-	f.lock.Lock()
-	defer f.lock.Unlock()
-
-	informerType := reflect.TypeOf(&rbac.Role{})
-	informer, exists := f.informers[informerType]
-	if exists {
-		return informer
-	}
-	informer = cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
-				return f.internalclient.Rbac().Roles(metav1.NamespaceAll).List(convertListOptionsOrDie(options))
-			},
-			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
-				return f.internalclient.Rbac().Roles(metav1.NamespaceAll).Watch(convertListOptionsOrDie(options))
-			},
-		},
-		&rbac.Role{},
-		f.defaultResync,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-	f.informers[informerType] = informer
-
-	return informer
-}
-
-func (f *roleInformer) Lister() listers.RoleLister {
-	return listers.NewRoleLister(f.Informer().GetIndexer())
-}
-
-type RoleBindingInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() listers.RoleBindingLister
-}
-
-type roleBindingInformer struct {
-	*sharedInformerFactory
-}
-
-func (f *roleBindingInformer) Informer() cache.SharedIndexInformer {
-	f.lock.Lock()
-	defer f.lock.Unlock()
-
-	informerType := reflect.TypeOf(&rbac.RoleBinding{})
-	informer, exists := f.informers[informerType]
-	if exists {
-		return informer
-	}
-	informer = cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
-				return f.internalclient.Rbac().RoleBindings(metav1.NamespaceAll).List(convertListOptionsOrDie(options))
-			},
-			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
-				return f.internalclient.Rbac().RoleBindings(metav1.NamespaceAll).Watch(convertListOptionsOrDie(options))
-			},
-		},
-		&rbac.RoleBinding{},
-		f.defaultResync,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-	f.informers[informerType] = informer
-
-	return informer
-}
-
-func (f *roleBindingInformer) Lister() listers.RoleBindingLister {
-	return listers.NewRoleBindingLister(f.Informer().GetIndexer())
-}
-
-func convertListOptionsOrDie(in metav1.ListOptions) metav1.ListOptions {
-	out := metav1.ListOptions{}
-	if err := api.Scheme.Convert(&in, &out, nil); err != nil {
-		panic(err)
-	}
-	return out
-}

pkg/controller/informers/storage.go

-/*
-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 informers
-
-import (
-	"reflect"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/watch"
-	"k8s.io/client-go/tools/cache"
-	storage "k8s.io/kubernetes/pkg/apis/storage/v1beta1"
-	"k8s.io/kubernetes/pkg/client/legacylisters"
-)
-
-// StorageClassInformer is type of SharedIndexInformer which watches and lists all storage classes.
-// Interface provides constructor for informer and lister for storage classes
-type StorageClassInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() listers.StorageClassLister
-}
-
-type storageClassInformer struct {
-	*sharedInformerFactory
-}
-
-func (f *storageClassInformer) Informer() cache.SharedIndexInformer {
-	f.lock.Lock()
-	defer f.lock.Unlock()
-
-	informerType := reflect.TypeOf(&storage.StorageClass{})
-	informer, exists := f.informers[informerType]
-	if exists {
-		return informer
-	}
-	informer = cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
-				return f.client.Storage().StorageClasses().List(options)
-			},
-			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
-				return f.client.Storage().StorageClasses().Watch(options)
-			},
-		},
-		&storage.StorageClass{},
-		f.defaultResync,
-		cache.Indexers{},
-	)
-	f.informers[informerType] = informer
-
-	return informer
-}
-
-func (f *storageClassInformer) Lister() listers.StorageClassLister {
-	informer := f.Informer()
-	return listers.NewStorageClassLister(informer.GetIndexer())
-}

pkg/controller/statefulset/BUILD

@@ -62,7 +62,6 @@ go_test(
         "//pkg/client/informers/informers_generated/externalversions:go_default_library",
         "//pkg/client/informers/informers_generated/externalversions/apps/v1beta1:go_default_library",
         "//pkg/client/informers/informers_generated/externalversions/core/v1:go_default_library",
-        "//pkg/client/legacylisters:go_default_library",
         "//pkg/client/listers/apps/v1beta1:go_default_library",
         "//pkg/client/listers/core/v1:go_default_library",
         "//pkg/controller:go_default_library",

pkg/controller/statefulset/stateful_pod_control.go

@@ -21,7 +21,6 @@ import (
 	"strings"
 
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	errorutils "k8s.io/apimachinery/pkg/util/errors"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/client-go/pkg/api"
@@ -56,8 +55,14 @@ type StatefulPodControlInterface interface {
 	UpdateStatefulSetReplicas(set *apps.StatefulSet, replicas int32) error
 }
 
-func NewRealStatefulPodControl(client clientset.Interface, setLister appslisters.StatefulSetLister, podLister corelisters.PodLister, recorder record.EventRecorder) StatefulPodControlInterface {
-	return &realStatefulPodControl{client, setLister, podLister, recorder}
+func NewRealStatefulPodControl(
+	client clientset.Interface,
+	setLister appslisters.StatefulSetLister,
+	podLister corelisters.PodLister,
+	pvcLister corelisters.PersistentVolumeClaimLister,
+	recorder record.EventRecorder,
+) StatefulPodControlInterface {
+	return &realStatefulPodControl{client, setLister, podLister, pvcLister, recorder}
 }
 
 // realStatefulPodControl implements StatefulPodControlInterface using a clientset.Interface to communicate with the
@@ -66,6 +71,7 @@ type realStatefulPodControl struct {
 	client    clientset.Interface
 	setLister appslisters.StatefulSetLister
 	podLister corelisters.PodLister
+	pvcLister corelisters.PersistentVolumeClaimLister
 	recorder  record.EventRecorder
 }
 
@@ -209,18 +215,19 @@ func (spc *realStatefulPodControl) recordClaimEvent(verb string, set *apps.State
 func (spc *realStatefulPodControl) createPersistentVolumeClaims(set *apps.StatefulSet, pod *v1.Pod) error {
 	var errs []error
 	for _, claim := range getPersistentVolumeClaims(set, pod) {
-		_, err := spc.client.Core().PersistentVolumeClaims(claim.Namespace).Get(claim.Name, metav1.GetOptions{})
-		if err != nil {
-			if apierrors.IsNotFound(err) {
-				_, err := spc.client.Core().PersistentVolumeClaims(claim.Namespace).Create(&claim)
-				if err != nil {
-					errs = append(errs, fmt.Errorf("Failed to create PVC %s: %s", claim.Name, err))
-				}
-				spc.recordClaimEvent("create", set, pod, &claim, err)
-			} else {
-				errs = append(errs, fmt.Errorf("Failed to retrieve PVC %s: %s", claim.Name, err))
+		_, err := spc.pvcLister.PersistentVolumeClaims(claim.Namespace).Get(claim.Name)
+		switch {
+		case apierrors.IsNotFound(err):
+			_, err := spc.client.Core().PersistentVolumeClaims(claim.Namespace).Create(&claim)
+			if err != nil {
+				errs = append(errs, fmt.Errorf("Failed to create PVC %s: %s", claim.Name, err))
+			}
+			if err == nil || !apierrors.IsAlreadyExists(err) {
 				spc.recordClaimEvent("create", set, pod, &claim, err)
 			}
+		case err != nil:
+			errs = append(errs, fmt.Errorf("Failed to retrieve PVC %s: %s", claim.Name, err))
+			spc.recordClaimEvent("create", set, pod, &claim, err)
 		}
 		// TODO: Check resource requirements and accessmodes, update if necessary
 	}

pkg/controller/statefulset/stateful_set.go

@@ -72,6 +72,7 @@ type StatefulSetController struct {
 func NewStatefulSetController(
 	podInformer coreinformers.PodInformer,
 	setInformer appsinformers.StatefulSetInformer,
+	pvcInformer coreinformers.PersistentVolumeClaimInformer,
 	kubeClient clientset.Interface,
 ) *StatefulSetController {
 	eventBroadcaster := record.NewBroadcaster()
@@ -81,8 +82,16 @@ func NewStatefulSetController(
 
 	ssc := &StatefulSetController{
 		kubeClient: kubeClient,
-		control:    NewDefaultStatefulSetControl(NewRealStatefulPodControl(kubeClient, setInformer.Lister(), podInformer.Lister(), recorder)),
-		queue:      workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "statefulset"),
+		control: NewDefaultStatefulSetControl(
+			NewRealStatefulPodControl(
+				kubeClient,
+				setInformer.Lister(),
+				podInformer.Lister(),
+				pvcInformer.Lister(),
+				recorder,
+			),
+		),
+		queue: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "statefulset"),
 	}
 
 	podInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{

pkg/controller/statefulset/stateful_set_control_test.go

@@ -34,7 +34,6 @@ import (
 	informers "k8s.io/kubernetes/pkg/client/informers/informers_generated/externalversions"
 	appsinformers "k8s.io/kubernetes/pkg/client/informers/informers_generated/externalversions/apps/v1beta1"
 	coreinformers "k8s.io/kubernetes/pkg/client/informers/informers_generated/externalversions/core/v1"
-	listers "k8s.io/kubernetes/pkg/client/legacylisters"
 	appslisters "k8s.io/kubernetes/pkg/client/listers/apps/v1beta1"
 	corelisters "k8s.io/kubernetes/pkg/client/listers/core/v1"
 	"k8s.io/kubernetes/pkg/controller"
@@ -560,7 +559,7 @@ func (rt *requestTracker) reset() {
 
 type fakeStatefulPodControl struct {
 	podsLister          corelisters.PodLister
-	claimsLister        listers.StoreToPersistentVolumeClaimLister
+	claimsLister        corelisters.PersistentVolumeClaimLister
 	setsLister          appslisters.StatefulSetLister
 	podsIndexer         cache.Indexer
 	claimsIndexer       cache.Indexer
@@ -572,11 +571,10 @@ type fakeStatefulPodControl struct {
 }
 
 func newFakeStatefulPodControl(podInformer coreinformers.PodInformer, setInformer appsinformers.StatefulSetInformer) *fakeStatefulPodControl {
-	claimsIndexer := cache.NewIndexer(controller.KeyFunc,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+	claimsIndexer := cache.NewIndexer(controller.KeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
 	return &fakeStatefulPodControl{
 		podInformer.Lister(),
-		listers.StoreToPersistentVolumeClaimLister{Indexer: claimsIndexer},
+		corelisters.NewPersistentVolumeClaimLister(claimsIndexer),
 		setInformer.Lister(),
 		podInformer.Informer().GetIndexer(),
 		claimsIndexer,

pkg/controller/statefulset/stateful_set_test.go

@@ -352,6 +352,7 @@ func newFakeStatefulSetController() (*StatefulSetController, *fakeStatefulPodCon
 	ssc := NewStatefulSetController(
 		informerFactory.Core().V1().Pods(),
 		informerFactory.Apps().V1beta1().StatefulSets(),
+		informerFactory.Core().V1().PersistentVolumeClaims(),
 		client,
 	)
 	ssc.podListerSynced = alwaysReady