Add ConcurrentDeploymentSyncs to avoid reuse ConcurrentDeploymentSyncs and keep UserAgentName var style consistent

Add some logs for debugging and add concurrent-deployment-syncs flag

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

@@ -141,20 +141,20 @@ func StartControllers(s *options.CMServer, restClientCfg *restclient.Config) err
 		if err != nil {
 			glog.Fatalf("Cloud provider could not be initialized: %v", err)
 		}
-		glog.Infof("Loading client config for service controller %q", servicecontroller.UserAgentName)
+		glog.V(3).Infof("Loading client config for service controller %q", servicecontroller.UserAgentName)
 		scClientset := federationclientset.NewForConfigOrDie(restclient.AddUserAgent(restClientCfg, servicecontroller.UserAgentName))
 		servicecontroller := servicecontroller.New(scClientset, dns, s.FederationName, s.ServiceDnsSuffix, s.ZoneName, s.ZoneID)
-		glog.Infof("Running service controller")
+		glog.V(3).Infof("Running service controller")
 		if err := servicecontroller.Run(s.ConcurrentServiceSyncs, wait.NeverStop); err != nil {
 			glog.Fatalf("Failed to start service controller: %v", err)
 		}
 	}
 
 	if controllerEnabled(s.Controllers, serverResources, namespacecontroller.ControllerName, namespacecontroller.RequiredResources, true) {
-		glog.Infof("Loading client config for namespace controller %q", "namespace-controller")
+		glog.V(3).Infof("Loading client config for namespace controller %q", namespacecontroller.UserAgentName)
-		nsClientset := federationclientset.NewForConfigOrDie(restclient.AddUserAgent(restClientCfg, "namespace-controller"))
+		nsClientset := federationclientset.NewForConfigOrDie(restclient.AddUserAgent(restClientCfg, namespacecontroller.UserAgentName))
-		namespaceController := namespacecontroller.NewNamespaceController(nsClientset, dynamic.NewDynamicClientPool(restclient.AddUserAgent(restClientCfg, "namespace-controller")))
+		namespaceController := namespacecontroller.NewNamespaceController(nsClientset, dynamic.NewDynamicClientPool(restclient.AddUserAgent(restClientCfg, namespacecontroller.UserAgentName)))
-		glog.Infof("Running namespace controller")
+		glog.V(3).Infof("Running namespace controller")
 		namespaceController.Run(wait.NeverStop)
 	}
 
@@ -165,23 +165,27 @@ func StartControllers(s *options.CMServer, restClientCfg *restclient.Config) err
 	}
 
 	if controllerEnabled(s.Controllers, serverResources, replicasetcontroller.ControllerName, replicasetcontroller.RequiredResources, true) {
+		glog.V(3).Infof("Loading client config for replica set controller %q", replicasetcontroller.UserAgentName)
 		replicaSetClientset := federationclientset.NewForConfigOrDie(restclient.AddUserAgent(restClientCfg, replicasetcontroller.UserAgentName))
 		replicaSetController := replicasetcontroller.NewReplicaSetController(replicaSetClientset)
+		glog.V(3).Infof("Running replica set controller")
 		go replicaSetController.Run(s.ConcurrentReplicaSetSyncs, wait.NeverStop)
 	}
 
 	if controllerEnabled(s.Controllers, serverResources, deploymentcontroller.ControllerName, deploymentcontroller.RequiredResources, true) {
+		glog.V(3).Infof("Loading client config for deployment controller %q", deploymentcontroller.UserAgentName)
 		deploymentClientset := federationclientset.NewForConfigOrDie(restclient.AddUserAgent(restClientCfg, deploymentcontroller.UserAgentName))
 		deploymentController := deploymentcontroller.NewDeploymentController(deploymentClientset)
-		// TODO: rename s.ConcurentReplicaSetSyncs
+		glog.V(3).Infof("Running deployment controller")
+		// TODO: rename s.ConcurrentReplicaSetSyncs
 		go deploymentController.Run(s.ConcurrentReplicaSetSyncs, wait.NeverStop)
 	}
 
 	if controllerEnabled(s.Controllers, serverResources, ingresscontroller.ControllerName, ingresscontroller.RequiredResources, true) {
-		glog.Infof("Loading client config for ingress controller %q", "ingress-controller")
+		glog.V(3).Infof("Loading client config for ingress controller %q", ingresscontroller.UserAgentName)
-		ingClientset := federationclientset.NewForConfigOrDie(restclient.AddUserAgent(restClientCfg, "ingress-controller"))
+		ingClientset := federationclientset.NewForConfigOrDie(restclient.AddUserAgent(restClientCfg, ingresscontroller.UserAgentName))
 		ingressController := ingresscontroller.NewIngressController(ingClientset)
-		glog.Infof("Running ingress controller")
+		glog.V(3).Infof("Running ingress controller")
 		ingressController.Run(wait.NeverStop)
 	}
 

federation/pkg/federation-controller/deployment/deploymentcontroller.go

@@ -54,7 +54,7 @@ import (
 const (
 	FedDeploymentPreferencesAnnotation = "federation.kubernetes.io/deployment-preferences"
 	allClustersKey                     = "THE_ALL_CLUSTER_KEY"
-	UserAgentName                      = "Federation-Deployment-Controller"
+	UserAgentName                      = "federation-deployment-controller"
 	ControllerName                     = "deployments"
 )
 
@@ -108,7 +108,7 @@ type DeploymentController struct {
 func NewDeploymentController(federationClient fedclientset.Interface) *DeploymentController {
 	broadcaster := record.NewBroadcaster()
 	broadcaster.StartRecordingToSink(eventsink.NewFederatedEventSink(federationClient))
-	recorder := broadcaster.NewRecorder(api.Scheme, clientv1.EventSource{Component: "federated-deployment-controller"})
+	recorder := broadcaster.NewRecorder(api.Scheme, clientv1.EventSource{Component: UserAgentName})
 
 	fdc := &DeploymentController{
 		fedClient:           federationClient,

federation/pkg/federation-controller/ingress/ingress_controller.go

@@ -63,6 +63,7 @@ const (
 	// other cluster.
 	firstClusterAnnotation = "ingress.federation.kubernetes.io/first-cluster"
 	ControllerName         = "ingresses"
+	UserAgentName          = "federation-ingresses-controller"
 )
 
 var (
@@ -122,7 +123,7 @@ func NewIngressController(client federationclientset.Interface) *IngressControll
 	glog.V(4).Infof("->NewIngressController V(4)")
 	broadcaster := record.NewBroadcaster()
 	broadcaster.StartRecordingToSink(eventsink.NewFederatedEventSink(client))
-	recorder := broadcaster.NewRecorder(api.Scheme, clientv1.EventSource{Component: "federated-ingress-controller"})
+	recorder := broadcaster.NewRecorder(api.Scheme, clientv1.EventSource{Component: UserAgentName})
 	ic := &IngressController{
 		federatedApiClient:    client,
 		ingressReviewDelay:    time.Second * 10,

federation/pkg/federation-controller/namespace/namespace_controller.go

@@ -47,6 +47,7 @@ import (
 const (
 	allClustersKey = "ALL_CLUSTERS"
 	ControllerName = "namespaces"
+	UserAgentName  = "federation-namespace-controller"
 )
 
 var (
@@ -96,7 +97,7 @@ type NamespaceController struct {
 func NewNamespaceController(client federationclientset.Interface, dynamicClientPool dynamic.ClientPool) *NamespaceController {
 	broadcaster := record.NewBroadcaster()
 	broadcaster.StartRecordingToSink(eventsink.NewFederatedEventSink(client))
-	recorder := broadcaster.NewRecorder(api.Scheme, clientv1.EventSource{Component: "federated-namespace-controller"})
+	recorder := broadcaster.NewRecorder(api.Scheme, clientv1.EventSource{Component: UserAgentName})
 
 	nc := &NamespaceController{
 		federatedApiClient:    client,

federation/pkg/federation-controller/replicaset/replicasetcontroller.go

@@ -57,7 +57,7 @@ import (
 const (
 	FedReplicaSetPreferencesAnnotation = "federation.kubernetes.io/replica-set-preferences"
 	allClustersKey                     = "THE_ALL_CLUSTER_KEY"
-	UserAgentName                      = "Federation-replicaset-Controller"
+	UserAgentName                      = "federation-replicaset-controller"
 	ControllerName                     = "replicasets"
 )
 
@@ -113,7 +113,7 @@ type ReplicaSetController struct {
 func NewReplicaSetController(federationClient fedclientset.Interface) *ReplicaSetController {
 	broadcaster := record.NewBroadcaster()
 	broadcaster.StartRecordingToSink(eventsink.NewFederatedEventSink(federationClient))
-	recorder := broadcaster.NewRecorder(api.Scheme, clientv1.EventSource{Component: "federated-replicaset-controller"})
+	recorder := broadcaster.NewRecorder(api.Scheme, clientv1.EventSource{Component: UserAgentName})
 
 	frsc := &ReplicaSetController{
 		fedClient:           federationClient,

federation/pkg/federation-controller/sync/controller.go

@@ -88,7 +88,7 @@ type FederationSyncController struct {
 
 // StartFederationSyncController starts a new sync controller for a type adapter
 func StartFederationSyncController(kind string, adapterFactory federatedtypes.AdapterFactory, config *restclient.Config, stopChan <-chan struct{}, minimizeLatency bool) {
-	restclient.AddUserAgent(config, fmt.Sprintf("%s-controller", kind))
+	restclient.AddUserAgent(config, fmt.Sprintf("federation-%s-controller", kind))
 	client := federationclientset.NewForConfigOrDie(config)
 	adapter := adapterFactory(client)
 	controller := newFederationSyncController(client, adapter)
@@ -103,7 +103,7 @@ func StartFederationSyncController(kind string, adapterFactory federatedtypes.Ad
 func newFederationSyncController(client federationclientset.Interface, adapter federatedtypes.FederatedTypeAdapter) *FederationSyncController {
 	broadcaster := record.NewBroadcaster()
 	broadcaster.StartRecordingToSink(eventsink.NewFederatedEventSink(client))
-	recorder := broadcaster.NewRecorder(api.Scheme, clientv1.EventSource{Component: fmt.Sprintf("federated-%v-controller", adapter.Kind())})
+	recorder := broadcaster.NewRecorder(api.Scheme, clientv1.EventSource{Component: fmt.Sprintf("federation-%v-controller", adapter.Kind())})
 
 	s := &FederationSyncController{
 		reviewDelay:           time.Second * 10,