github/kubernetes
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

replace the client with clientset in controllers

Browse Source
This commit is contained in:
Chao Xu
2016-01-28 22:34:08 -08:00
parent 126f798699
commit fe7887f1ec
35 changed files with 430 additions and 332 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
cmd/integration/integration.go
View File

@@ -187,14 +187,14 @@ func startComponents(firstManifestURL, secondManifestURL string) (string, string
scheduler.New(schedulerConfig).Run() scheduler.New(schedulerConfig).Run()
// ensure the service endpoints are sync'd several times within the window that the integration tests wait // ensure the service endpoints are sync'd several times within the window that the integration tests wait
go endpointcontroller.NewEndpointController(cl, controller.NoResyncPeriodFunc). go endpointcontroller.NewEndpointController(clientset, controller.NoResyncPeriodFunc).
Run(3, util.NeverStop) Run(3, util.NeverStop)
// TODO: Write an integration test for the replication controllers watch. // TODO: Write an integration test for the replication controllers watch.
go replicationcontroller.NewReplicationManager(clientset, controller.NoResyncPeriodFunc, replicationcontroller.BurstReplicas). go replicationcontroller.NewReplicationManager(clientset, controller.NoResyncPeriodFunc, replicationcontroller.BurstReplicas).
Run(3, util.NeverStop) Run(3, util.NeverStop)
nodeController := nodecontroller.NewNodeController(nil, cl, 5*time.Minute, util.NewFakeRateLimiter(), util.NewFakeRateLimiter(), nodeController := nodecontroller.NewNodeController(nil, clientset, 5*time.Minute, util.NewFakeRateLimiter(), util.NewFakeRateLimiter(),
40*time.Second, 60*time.Second, 5*time.Second, nil, false) 40*time.Second, 60*time.Second, 5*time.Second, nil, false)
nodeController.Run(5 * time.Second) nodeController.Run(5 * time.Second)
cadvisorInterface := new(cadvisor.Fake) cadvisorInterface := new(cadvisor.Fake)

22
cmd/kube-controller-manager/app/controllermanager.go
View File

@@ -173,7 +173,7 @@ func Run(s *options.CMServer) error {
} }
func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig *client.Config, stop <-chan struct{}) error { func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig *client.Config, stop <-chan struct{}) error {
go endpointcontroller.NewEndpointController(client.NewOrDie(client.AddUserAgent(kubeconfig, "endpoint-controller")), ResyncPeriod(s)). go endpointcontroller.NewEndpointController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "endpoint-controller")), ResyncPeriod(s)).
Run(s.ConcurrentEndpointSyncs, util.NeverStop) Run(s.ConcurrentEndpointSyncs, util.NeverStop)
go replicationcontroller.NewReplicationManager( go replicationcontroller.NewReplicationManager(
@@ -183,7 +183,7 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig
).Run(s.ConcurrentRCSyncs, util.NeverStop) ).Run(s.ConcurrentRCSyncs, util.NeverStop)
if s.TerminatedPodGCThreshold > 0 { if s.TerminatedPodGCThreshold > 0 {
go gc.New(client.NewOrDie(client.AddUserAgent(kubeconfig, "garbage-collector")), ResyncPeriod(s), s.TerminatedPodGCThreshold). go gc.New(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "garbage-collector")), ResyncPeriod(s), s.TerminatedPodGCThreshold).
Run(util.NeverStop) Run(util.NeverStop)
} }
@@ -192,13 +192,13 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig
glog.Fatalf("Cloud provider could not be initialized: %v", err) glog.Fatalf("Cloud provider could not be initialized: %v", err)
} }
nodeController := nodecontroller.NewNodeController(cloud, client.NewOrDie(client.AddUserAgent(kubeconfig, "node-controller")), nodeController := nodecontroller.NewNodeController(cloud, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "node-controller")),
s.PodEvictionTimeout, util.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst), s.PodEvictionTimeout, util.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst),
util.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst), util.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst),
s.NodeMonitorGracePeriod, s.NodeStartupGracePeriod, s.NodeMonitorPeriod, &s.ClusterCIDR, s.AllocateNodeCIDRs) s.NodeMonitorGracePeriod, s.NodeStartupGracePeriod, s.NodeMonitorPeriod, &s.ClusterCIDR, s.AllocateNodeCIDRs)
nodeController.Run(s.NodeSyncPeriod) nodeController.Run(s.NodeSyncPeriod)
serviceController := servicecontroller.New(cloud, client.NewOrDie(client.AddUserAgent(kubeconfig, "service-controller")), s.ClusterName) serviceController := servicecontroller.New(cloud, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "service-controller")), s.ClusterName)
if err := serviceController.Run(s.ServiceSyncPeriod, s.NodeSyncPeriod); err != nil { if err := serviceController.Run(s.ServiceSyncPeriod, s.NodeSyncPeriod); err != nil {
glog.Errorf("Failed to start service controller: %v", err) glog.Errorf("Failed to start service controller: %v", err)
} }
@@ -209,7 +209,7 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig
} else if routes, ok := cloud.Routes(); !ok { } else if routes, ok := cloud.Routes(); !ok {
glog.Warning("allocate-node-cidrs is set, but cloud provider does not support routes. Will not manage routes.") glog.Warning("allocate-node-cidrs is set, but cloud provider does not support routes. Will not manage routes.")
} else { } else {
routeController := routecontroller.New(routes, client.NewOrDie(client.AddUserAgent(kubeconfig, "route-controller")), s.ClusterName, &s.ClusterCIDR) routeController := routecontroller.New(routes, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "route-controller")), s.ClusterName, &s.ClusterCIDR)
routeController.Run(s.NodeSyncPeriod) routeController.Run(s.NodeSyncPeriod)
} }
} else { } else {
@@ -217,7 +217,7 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig
} }
go resourcequotacontroller.NewResourceQuotaController( go resourcequotacontroller.NewResourceQuotaController(
client.NewOrDie(client.AddUserAgent(kubeconfig, "resourcequota-controller")), clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "resourcequota-controller")),
controller.StaticResyncPeriodFunc(s.ResourceQuotaSyncPeriod)).Run(s.ConcurrentResourceQuotaSyncs, util.NeverStop) controller.StaticResyncPeriodFunc(s.ResourceQuotaSyncPeriod)).Run(s.ConcurrentResourceQuotaSyncs, util.NeverStop)
// If apiserver is not running we should wait for some time and fail only then. This is particularly // If apiserver is not running we should wait for some time and fail only then. This is particularly
@@ -240,7 +240,7 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig
glog.Fatalf("Failed to get supported resources from server: %v", err) glog.Fatalf("Failed to get supported resources from server: %v", err)
} }
namespacecontroller.NewNamespaceController(client.NewOrDie(client.AddUserAgent(kubeconfig, "namespace-controller")), versions, s.NamespaceSyncPeriod).Run() namespacecontroller.NewNamespaceController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "namespace-controller")), versions, s.NamespaceSyncPeriod).Run()
groupVersion := "extensions/v1beta1" groupVersion := "extensions/v1beta1"
resources, found := resourceMap[groupVersion] resources, found := resourceMap[groupVersion]
@@ -249,7 +249,7 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig
glog.Infof("Starting %s apis", groupVersion) glog.Infof("Starting %s apis", groupVersion)
if containsResource(resources, "horizontalpodautoscalers") { if containsResource(resources, "horizontalpodautoscalers") {
glog.Infof("Starting horizontal pod controller.") glog.Infof("Starting horizontal pod controller.")
hpaClient := client.NewOrDie(client.AddUserAgent(kubeconfig, "horizontal-pod-autoscaler")) hpaClient := clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "horizontal-pod-autoscaler"))
metricsClient := metrics.NewHeapsterMetricsClient( metricsClient := metrics.NewHeapsterMetricsClient(
hpaClient, hpaClient,
metrics.DefaultHeapsterNamespace, metrics.DefaultHeapsterNamespace,
@@ -257,7 +257,7 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig
metrics.DefaultHeapsterService, metrics.DefaultHeapsterService,
metrics.DefaultHeapsterPort, metrics.DefaultHeapsterPort,
) )
podautoscaler.NewHorizontalController(hpaClient, hpaClient, hpaClient, metricsClient). podautoscaler.NewHorizontalController(hpaClient.Legacy(), hpaClient.Extensions(), hpaClient, metricsClient).
Run(s.HorizontalPodAutoscalerSyncPeriod) Run(s.HorizontalPodAutoscalerSyncPeriod)
} }
@@ -323,7 +323,7 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig
glog.Errorf("Error reading key for service account token controller: %v", err) glog.Errorf("Error reading key for service account token controller: %v", err)
} else { } else {
serviceaccountcontroller.NewTokensController( serviceaccountcontroller.NewTokensController(
client.NewOrDie(client.AddUserAgent(kubeconfig, "tokens-controller")), clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "tokens-controller")),
serviceaccountcontroller.TokensControllerOptions{ serviceaccountcontroller.TokensControllerOptions{
TokenGenerator: serviceaccount.JWTTokenGenerator(privateKey), TokenGenerator: serviceaccount.JWTTokenGenerator(privateKey),
RootCA: rootCA, RootCA: rootCA,
@@ -333,7 +333,7 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig
} }
serviceaccountcontroller.NewServiceAccountsController( serviceaccountcontroller.NewServiceAccountsController(
client.NewOrDie(client.AddUserAgent(kubeconfig, "service-account-controller")), clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "service-account-controller")),
serviceaccountcontroller.DefaultServiceAccountsControllerOptions(), serviceaccountcontroller.DefaultServiceAccountsControllerOptions(),
).Run() ).Run()

24
contrib/mesos/pkg/controllermanager/controllermanager.go
View File

@@ -127,14 +127,14 @@ func (s *CMServer) Run(_ []string) error {
glog.Fatal(server.ListenAndServe()) glog.Fatal(server.ListenAndServe())
}() }()
endpoints := s.createEndpointController(client.NewOrDie(client.AddUserAgent(kubeconfig, "endpoint-controller"))) endpoints := s.createEndpointController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "endpoint-controller")))
go endpoints.Run(s.ConcurrentEndpointSyncs, util.NeverStop) go endpoints.Run(s.ConcurrentEndpointSyncs, util.NeverStop)
go replicationcontroller.NewReplicationManager(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "replication-controller")), s.resyncPeriod, replicationcontroller.BurstReplicas). go replicationcontroller.NewReplicationManager(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "replication-controller")), s.resyncPeriod, replicationcontroller.BurstReplicas).
Run(s.ConcurrentRCSyncs, util.NeverStop) Run(s.ConcurrentRCSyncs, util.NeverStop)
if s.TerminatedPodGCThreshold > 0 { if s.TerminatedPodGCThreshold > 0 {
go gc.New(client.NewOrDie(client.AddUserAgent(kubeconfig, "garbage-collector")), s.resyncPeriod, s.TerminatedPodGCThreshold). go gc.New(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "garbage-collector")), s.resyncPeriod, s.TerminatedPodGCThreshold).
Run(util.NeverStop) Run(util.NeverStop)
} }
@@ -147,7 +147,7 @@ func (s *CMServer) Run(_ []string) error {
glog.Fatalf("Cloud provider could not be initialized: %v", err) glog.Fatalf("Cloud provider could not be initialized: %v", err)
} }
nodeController := nodecontroller.NewNodeController(cloud, client.NewOrDie(client.AddUserAgent(kubeconfig, "node-controller")), nodeController := nodecontroller.NewNodeController(cloud, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "node-controller")),
s.PodEvictionTimeout, util.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst), s.PodEvictionTimeout, util.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst),
util.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst), util.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst),
s.NodeMonitorGracePeriod, s.NodeStartupGracePeriod, s.NodeMonitorPeriod, (*net.IPNet)(&s.ClusterCIDR), s.AllocateNodeCIDRs) s.NodeMonitorGracePeriod, s.NodeStartupGracePeriod, s.NodeMonitorPeriod, (*net.IPNet)(&s.ClusterCIDR), s.AllocateNodeCIDRs)
@@ -158,7 +158,7 @@ func (s *CMServer) Run(_ []string) error {
glog.Fatalf("Failed to start node status update controller: %v", err) glog.Fatalf("Failed to start node status update controller: %v", err)
} }
serviceController := servicecontroller.New(cloud, client.NewOrDie(client.AddUserAgent(kubeconfig, "service-controller")), s.ClusterName) serviceController := servicecontroller.New(cloud, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "service-controller")), s.ClusterName)
if err := serviceController.Run(s.ServiceSyncPeriod, s.NodeSyncPeriod); err != nil { if err := serviceController.Run(s.ServiceSyncPeriod, s.NodeSyncPeriod); err != nil {
glog.Errorf("Failed to start service controller: %v", err) glog.Errorf("Failed to start service controller: %v", err)
} }
@@ -168,12 +168,12 @@ func (s *CMServer) Run(_ []string) error {
if !ok { if !ok {
glog.Fatal("Cloud provider must support routes if allocate-node-cidrs is set") glog.Fatal("Cloud provider must support routes if allocate-node-cidrs is set")
} }
routeController := routecontroller.New(routes, client.NewOrDie(client.AddUserAgent(kubeconfig, "route-controller")), s.ClusterName, (*net.IPNet)(&s.ClusterCIDR)) routeController := routecontroller.New(routes, clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "route-controller")), s.ClusterName, (*net.IPNet)(&s.ClusterCIDR))
routeController.Run(s.NodeSyncPeriod) routeController.Run(s.NodeSyncPeriod)
} }
go resourcequotacontroller.NewResourceQuotaController( go resourcequotacontroller.NewResourceQuotaController(
client.NewOrDie(client.AddUserAgent(kubeconfig, "resource-quota-controller")), controller.StaticResyncPeriodFunc(s.ResourceQuotaSyncPeriod)).Run(s.ConcurrentResourceQuotaSyncs, util.NeverStop) clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "resource-quota-controller")), controller.StaticResyncPeriodFunc(s.ResourceQuotaSyncPeriod)).Run(s.ConcurrentResourceQuotaSyncs, util.NeverStop)
// If apiserver is not running we should wait for some time and fail only then. This is particularly // If apiserver is not running we should wait for some time and fail only then. This is particularly
// important when we start apiserver and controller manager at the same time. // important when we start apiserver and controller manager at the same time.
@@ -195,7 +195,7 @@ func (s *CMServer) Run(_ []string) error {
glog.Fatalf("Failed to get supported resources from server: %v", err) glog.Fatalf("Failed to get supported resources from server: %v", err)
} }
namespaceController := namespacecontroller.NewNamespaceController(client.NewOrDie(client.AddUserAgent(kubeconfig, "namespace-controller")), &unversioned.APIVersions{}, s.NamespaceSyncPeriod) namespaceController := namespacecontroller.NewNamespaceController(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "namespace-controller")), &unversioned.APIVersions{}, s.NamespaceSyncPeriod)
namespaceController.Run() namespaceController.Run()
groupVersion := "extensions/v1beta1" groupVersion := "extensions/v1beta1"
@@ -205,7 +205,7 @@ func (s *CMServer) Run(_ []string) error {
glog.Infof("Starting %s apis", groupVersion) glog.Infof("Starting %s apis", groupVersion)
if containsResource(resources, "horizontalpodautoscalers") { if containsResource(resources, "horizontalpodautoscalers") {
glog.Infof("Starting horizontal pod controller.") glog.Infof("Starting horizontal pod controller.")
hpaClient := client.NewOrDie(client.AddUserAgent(kubeconfig, "horizontal-pod-autoscaler")) hpaClient := clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "horizontal-pod-autoscaler"))
metricsClient := metrics.NewHeapsterMetricsClient( metricsClient := metrics.NewHeapsterMetricsClient(
hpaClient, hpaClient,
metrics.DefaultHeapsterNamespace, metrics.DefaultHeapsterNamespace,
@@ -213,7 +213,7 @@ func (s *CMServer) Run(_ []string) error {
metrics.DefaultHeapsterService, metrics.DefaultHeapsterService,
metrics.DefaultHeapsterPort, metrics.DefaultHeapsterPort,
) )
podautoscaler.NewHorizontalController(hpaClient, hpaClient, hpaClient, metricsClient). podautoscaler.NewHorizontalController(hpaClient.Legacy(), hpaClient.Extensions(), hpaClient, metricsClient).
Run(s.HorizontalPodAutoscalerSyncPeriod) Run(s.HorizontalPodAutoscalerSyncPeriod)
} }
@@ -279,7 +279,7 @@ func (s *CMServer) Run(_ []string) error {
glog.Errorf("Error reading key for service account token controller: %v", err) glog.Errorf("Error reading key for service account token controller: %v", err)
} else { } else {
serviceaccountcontroller.NewTokensController( serviceaccountcontroller.NewTokensController(
client.NewOrDie(client.AddUserAgent(kubeconfig, "tokens-controller")), clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "tokens-controller")),
serviceaccountcontroller.TokensControllerOptions{ serviceaccountcontroller.TokensControllerOptions{
TokenGenerator: serviceaccount.JWTTokenGenerator(privateKey), TokenGenerator: serviceaccount.JWTTokenGenerator(privateKey),
RootCA: rootCA, RootCA: rootCA,
@@ -289,14 +289,14 @@ func (s *CMServer) Run(_ []string) error {
} }
serviceaccountcontroller.NewServiceAccountsController( serviceaccountcontroller.NewServiceAccountsController(
client.NewOrDie(client.AddUserAgent(kubeconfig, "service-account-controller")), clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "service-account-controller")),
serviceaccountcontroller.DefaultServiceAccountsControllerOptions(), serviceaccountcontroller.DefaultServiceAccountsControllerOptions(),
).Run() ).Run()
select {} select {}
} }
func (s *CMServer) createEndpointController(client *client.Client) kmendpoint.EndpointController { func (s *CMServer) createEndpointController(client *clientset.Clientset) kmendpoint.EndpointController {
if s.UseHostPortEndpoints { if s.UseHostPortEndpoints {
glog.V(2).Infof("Creating hostIP:hostPort endpoint controller") glog.V(2).Infof("Creating hostIP:hostPort endpoint controller")
return kmendpoint.NewEndpointController(client) return kmendpoint.NewEndpointController(client)

16
contrib/mesos/pkg/service/endpoints_controller.go
View File

@@ -27,7 +27,7 @@ import (
"k8s.io/kubernetes/pkg/api/endpoints" "k8s.io/kubernetes/pkg/api/endpoints"
"k8s.io/kubernetes/pkg/api/errors" "k8s.io/kubernetes/pkg/api/errors"
"k8s.io/kubernetes/pkg/client/cache" "k8s.io/kubernetes/pkg/client/cache"
client "k8s.io/kubernetes/pkg/client/unversioned" clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
kservice "k8s.io/kubernetes/pkg/controller/endpoint" kservice "k8s.io/kubernetes/pkg/controller/endpoint"
"k8s.io/kubernetes/pkg/controller/framework" "k8s.io/kubernetes/pkg/controller/framework"
"k8s.io/kubernetes/pkg/labels" "k8s.io/kubernetes/pkg/labels"
@@ -51,7 +51,7 @@ type EndpointController interface {
} }
// NewEndpointController returns a new *EndpointController. // NewEndpointController returns a new *EndpointController.
func NewEndpointController(client *client.Client) *endpointController { func NewEndpointController(client *clientset.Clientset) *endpointController {
e := &endpointController{ e := &endpointController{
client: client, client: client,
queue: workqueue.New(), queue: workqueue.New(),
@@ -59,10 +59,10 @@ func NewEndpointController(client *client.Client) *endpointController {
e.serviceStore.Store, e.serviceController = framework.NewInformer( e.serviceStore.Store, e.serviceController = framework.NewInformer(
&cache.ListWatch{ &cache.ListWatch{
ListFunc: func(options api.ListOptions) (runtime.Object, error) { ListFunc: func(options api.ListOptions) (runtime.Object, error) {
return e.client.Services(api.NamespaceAll).List(options) return e.client.Legacy().Services(api.NamespaceAll).List(options)
}, },
WatchFunc: func(options api.ListOptions) (watch.Interface, error) { WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
return e.client.Services(api.NamespaceAll).Watch(options) return e.client.Legacy().Services(api.NamespaceAll).Watch(options)
}, },
}, },
&api.Service{}, &api.Service{},
@@ -79,10 +79,10 @@ func NewEndpointController(client *client.Client) *endpointController {
e.podStore.Store, e.podController = framework.NewInformer( e.podStore.Store, e.podController = framework.NewInformer(
&cache.ListWatch{ &cache.ListWatch{
ListFunc: func(options api.ListOptions) (runtime.Object, error) { ListFunc: func(options api.ListOptions) (runtime.Object, error) {
return e.client.Pods(api.NamespaceAll).List(options) return e.client.Legacy().Pods(api.NamespaceAll).List(options)
}, },
WatchFunc: func(options api.ListOptions) (watch.Interface, error) { WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
return e.client.Pods(api.NamespaceAll).Watch(options) return e.client.Legacy().Pods(api.NamespaceAll).Watch(options)
}, },
}, },
&api.Pod{}, &api.Pod{},
@@ -98,7 +98,7 @@ func NewEndpointController(client *client.Client) *endpointController {
// EndpointController manages selector-based service endpoints. // EndpointController manages selector-based service endpoints.
type endpointController struct { type endpointController struct {
client *client.Client client *clientset.Clientset
serviceStore cache.StoreToServiceLister serviceStore cache.StoreToServiceLister
podStore cache.StoreToPodLister podStore cache.StoreToPodLister
@@ -264,7 +264,7 @@ func (e *endpointController) syncService(key string) {
// Don't retry, as the key isn't going to magically become understandable. // Don't retry, as the key isn't going to magically become understandable.
return return
} }
err = e.client.Endpoints(namespace).Delete(name) err = e.client.Endpoints(namespace).Delete(name, nil)
if err != nil && !errors.IsNotFound(err) { if err != nil && !errors.IsNotFound(err) {
glog.Errorf("Error deleting endpoint %q: %v", key, err) glog.Errorf("Error deleting endpoint %q: %v", key, err)
e.queue.Add(key) // Retry e.queue.Add(key) // Retry

1
pkg/client/typed/generated/extensions/unversioned/deployment_expansion.go
View File

@@ -18,6 +18,7 @@ package unversioned
import "k8s.io/kubernetes/pkg/apis/extensions" import "k8s.io/kubernetes/pkg/apis/extensions"
// The DeploymentExpansion interface allows manually adding extra methods to the DeploymentInterface.
type DeploymentExpansion interface { type DeploymentExpansion interface {
Rollback(*extensions.DeploymentRollback) error Rollback(*extensions.DeploymentRollback) error
} }

2
pkg/client/typed/generated/extensions/unversioned/generated_expansion.go
View File

@@ -24,8 +24,6 @@ type IngressExpansion interface{}
type JobExpansion interface{} type JobExpansion interface{}
type ScaleExpansion interface{}
type ThirdPartyResourceExpansion interface{} type ThirdPartyResourceExpansion interface{}
type ReplicaSetExpansion interface{} type ReplicaSetExpansion interface{}

65
pkg/client/typed/generated/extensions/unversioned/scale_expansion.go Normal file
View File

@@ -0,0 +1,65 @@
/*
Copyright 2016 The Kubernetes Authors All rights reserved.
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 unversioned
import (
"k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/apis/extensions"
)
// The ScaleExpansion interface allows manually adding extra methods to the ScaleInterface.
type ScaleExpansion interface {
Get(kind string, name string) (*extensions.Scale, error)
Update(kind string, scale *extensions.Scale) (*extensions.Scale, error)
}
// Get takes the reference to scale subresource and returns the subresource or error, if one occurs.
func (c *scales) Get(kind string, name string) (result *extensions.Scale, err error) {
result = &extensions.Scale{}
// TODO this method needs to take a proper unambiguous kind
fullyQualifiedKind := unversioned.GroupVersionKind{Kind: kind}
resource, _ := meta.KindToResource(fullyQualifiedKind, false)
err = c.client.Get().
Namespace(c.ns).
Resource(resource.Resource).
Name(name).
SubResource("scale").
Do().
Into(result)
return
}
func (c *scales) Update(kind string, scale *extensions.Scale) (result *extensions.Scale, err error) {
result = &extensions.Scale{}
// TODO this method needs to take a proper unambiguous kind
fullyQualifiedKind := unversioned.GroupVersionKind{Kind: kind}
resource, _ := meta.KindToResource(fullyQualifiedKind, false)
err = c.client.Put().
Namespace(scale.Namespace).
Resource(resource.Resource).
Name(scale.Name).
SubResource("scale").
Body(scale).
Do().
Into(result)
return
}

1
pkg/client/typed/generated/legacy/unversioned/event_expansion.go
View File

@@ -24,6 +24,7 @@ import (
"k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/runtime"
) )
// The EventExpansion interface allows manually adding extra methods to the EventInterface.
type EventExpansion interface { type EventExpansion interface {
// CreateWithEventNamespace is the same as a Create, except that it sends the request to the event.Namespace. // CreateWithEventNamespace is the same as a Create, except that it sends the request to the event.Namespace.
CreateWithEventNamespace(event *api.Event) (*api.Event, error) CreateWithEventNamespace(event *api.Event) (*api.Event, error)

1
pkg/client/typed/generated/legacy/unversioned/namespace_expansion.go
View File

@@ -18,6 +18,7 @@ package unversioned
import "k8s.io/kubernetes/pkg/api" import "k8s.io/kubernetes/pkg/api"
// The NamespaceExpansion interface allows manually adding extra methods to the NamespaceInterface.
type NamespaceExpansion interface { type NamespaceExpansion interface {
Finalize(item *api.Namespace) (*api.Namespace, error) Finalize(item *api.Namespace) (*api.Namespace, error)
} }

1
pkg/client/typed/generated/legacy/unversioned/pod_expansion.go
View File

@@ -21,6 +21,7 @@ import (
unversioned "k8s.io/kubernetes/pkg/client/unversioned" unversioned "k8s.io/kubernetes/pkg/client/unversioned"
) )
// The PodExpansion interface allows manually adding extra methods to the PodInterface.
type PodExpansion interface { type PodExpansion interface {
Bind(binding *api.Binding) error Bind(binding *api.Binding) error
GetLogs(name string, opts *api.PodLogOptions) *unversioned.Request GetLogs(name string, opts *api.PodLogOptions) *unversioned.Request

1
pkg/client/typed/generated/legacy/unversioned/service_expansion.go
View File

@@ -21,6 +21,7 @@ import (
"k8s.io/kubernetes/pkg/util/net" "k8s.io/kubernetes/pkg/util/net"
) )
// The ServiceExpansion interface allows manually adding extra methods to the ServiceInterface.
type ServiceExpansion interface { type ServiceExpansion interface {
ProxyGet(scheme, name, port, path string, params map[string]string) unversioned.ResponseWrapper ProxyGet(scheme, name, port, path string, params map[string]string) unversioned.ResponseWrapper
} }

16
pkg/controller/endpoint/endpoints_controller.go
View File

@@ -27,7 +27,7 @@ import (
"k8s.io/kubernetes/pkg/api/errors" "k8s.io/kubernetes/pkg/api/errors"
podutil "k8s.io/kubernetes/pkg/api/pod" podutil "k8s.io/kubernetes/pkg/api/pod"
"k8s.io/kubernetes/pkg/client/cache" "k8s.io/kubernetes/pkg/client/cache"
client "k8s.io/kubernetes/pkg/client/unversioned" clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
"k8s.io/kubernetes/pkg/controller" "k8s.io/kubernetes/pkg/controller"
"k8s.io/kubernetes/pkg/controller/framework" "k8s.io/kubernetes/pkg/controller/framework"
"k8s.io/kubernetes/pkg/labels" "k8s.io/kubernetes/pkg/labels"
@@ -53,7 +53,7 @@ var (
) )
// NewEndpointController returns a new *EndpointController. // NewEndpointController returns a new *EndpointController.
func NewEndpointController(client *client.Client, resyncPeriod controller.ResyncPeriodFunc) *EndpointController { func NewEndpointController(client *clientset.Clientset, resyncPeriod controller.ResyncPeriodFunc) *EndpointController {
e := &EndpointController{ e := &EndpointController{
client: client, client: client,
queue: workqueue.New(), queue: workqueue.New(),
@@ -62,10 +62,10 @@ func NewEndpointController(client *client.Client, resyncPeriod controller.Resync
e.serviceStore.Store, e.serviceController = framework.NewInformer( e.serviceStore.Store, e.serviceController = framework.NewInformer(
&cache.ListWatch{ &cache.ListWatch{
ListFunc: func(options api.ListOptions) (runtime.Object, error) { ListFunc: func(options api.ListOptions) (runtime.Object, error) {
return e.client.Services(api.NamespaceAll).List(options) return e.client.Legacy().Services(api.NamespaceAll).List(options)
}, },
WatchFunc: func(options api.ListOptions) (watch.Interface, error) { WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
return e.client.Services(api.NamespaceAll).Watch(options) return e.client.Legacy().Services(api.NamespaceAll).Watch(options)
}, },
}, },
&api.Service{}, &api.Service{},
@@ -83,10 +83,10 @@ func NewEndpointController(client *client.Client, resyncPeriod controller.Resync
e.podStore.Store, e.podController = framework.NewInformer( e.podStore.Store, e.podController = framework.NewInformer(
&cache.ListWatch{ &cache.ListWatch{
ListFunc: func(options api.ListOptions) (runtime.Object, error) { ListFunc: func(options api.ListOptions) (runtime.Object, error) {
return e.client.Pods(api.NamespaceAll).List(options) return e.client.Legacy().Pods(api.NamespaceAll).List(options)
}, },
WatchFunc: func(options api.ListOptions) (watch.Interface, error) { WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
return e.client.Pods(api.NamespaceAll).Watch(options) return e.client.Legacy().Pods(api.NamespaceAll).Watch(options)
}, },
}, },
&api.Pod{}, &api.Pod{},
@@ -103,7 +103,7 @@ func NewEndpointController(client *client.Client, resyncPeriod controller.Resync
// EndpointController manages selector-based service endpoints. // EndpointController manages selector-based service endpoints.
type EndpointController struct { type EndpointController struct {
client *client.Client client *clientset.Clientset
serviceStore cache.StoreToServiceLister serviceStore cache.StoreToServiceLister
podStore cache.StoreToPodLister podStore cache.StoreToPodLister
@@ -268,7 +268,7 @@ func (e *EndpointController) syncService(key string) {
// Don't retry, as the key isn't going to magically become understandable. // Don't retry, as the key isn't going to magically become understandable.
return return
} }
err = e.client.Endpoints(namespace).Delete(name) err = e.client.Endpoints(namespace).Delete(name, nil)
if err != nil && !errors.IsNotFound(err) { if err != nil && !errors.IsNotFound(err) {
glog.Errorf("Error deleting endpoint %q: %v", key, err) glog.Errorf("Error deleting endpoint %q: %v", key, err)
e.queue.Add(key) // Retry e.queue.Add(key) // Retry

25
pkg/controller/endpoint/endpoints_controller_test.go
View File

@@ -28,6 +28,7 @@ import (
"k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/unversioned"
_ "k8s.io/kubernetes/pkg/apimachinery/registered" _ "k8s.io/kubernetes/pkg/apimachinery/registered"
"k8s.io/kubernetes/pkg/client/cache" "k8s.io/kubernetes/pkg/client/cache"
clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
client "k8s.io/kubernetes/pkg/client/unversioned" client "k8s.io/kubernetes/pkg/client/unversioned"
"k8s.io/kubernetes/pkg/controller" "k8s.io/kubernetes/pkg/controller"
"k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/runtime"
@@ -104,7 +105,7 @@ func TestSyncEndpointsItemsPreserveNoSelector(t *testing.T) {
}}) }})
// TODO: Uncomment when fix #19254 // TODO: Uncomment when fix #19254
// defer testServer.Close() // defer testServer.Close()
client := client.NewOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}}) client := clientset.NewForConfigOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}})
endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc) endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc)
endpoints.serviceStore.Store.Add(&api.Service{ endpoints.serviceStore.Store.Add(&api.Service{
ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: ns}, ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: ns},
@@ -137,7 +138,7 @@ func TestCheckLeftoverEndpoints(t *testing.T) {
}}) }})
// TODO: Uncomment when fix #19254 // TODO: Uncomment when fix #19254
// defer testServer.Close() // defer testServer.Close()
client := client.NewOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}}) client := clientset.NewForConfigOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}})
endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc) endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc)
endpoints.checkLeftoverEndpoints() endpoints.checkLeftoverEndpoints()
@@ -166,7 +167,7 @@ func TestSyncEndpointsProtocolTCP(t *testing.T) {
}}) }})
// TODO: Uncomment when fix #19254 // TODO: Uncomment when fix #19254
// defer testServer.Close() // defer testServer.Close()
client := client.NewOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}}) client := clientset.NewForConfigOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}})
endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc) endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc)
addPods(endpoints.podStore.Store, ns, 1, 1, 0) addPods(endpoints.podStore.Store, ns, 1, 1, 0)
endpoints.serviceStore.Store.Add(&api.Service{ endpoints.serviceStore.Store.Add(&api.Service{
@@ -208,7 +209,7 @@ func TestSyncEndpointsProtocolUDP(t *testing.T) {
}}) }})
// TODO: Uncomment when fix #19254 // TODO: Uncomment when fix #19254
// defer testServer.Close() // defer testServer.Close()
client := client.NewOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}}) client := clientset.NewForConfigOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}})
endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc) endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc)
addPods(endpoints.podStore.Store, ns, 1, 1, 0) addPods(endpoints.podStore.Store, ns, 1, 1, 0)
endpoints.serviceStore.Store.Add(&api.Service{ endpoints.serviceStore.Store.Add(&api.Service{
@@ -247,7 +248,7 @@ func TestSyncEndpointsItemsEmptySelectorSelectsAll(t *testing.T) {
}}) }})
// TODO: Uncomment when fix #19254 // TODO: Uncomment when fix #19254
// defer testServer.Close() // defer testServer.Close()
client := client.NewOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}}) client := clientset.NewForConfigOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}})
endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc) endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc)
addPods(endpoints.podStore.Store, ns, 1, 1, 0) addPods(endpoints.podStore.Store, ns, 1, 1, 0)
endpoints.serviceStore.Store.Add(&api.Service{ endpoints.serviceStore.Store.Add(&api.Service{
@@ -285,7 +286,7 @@ func TestSyncEndpointsItemsEmptySelectorSelectsAllNotReady(t *testing.T) {
}}) }})
// TODO: Uncomment when fix #19254 // TODO: Uncomment when fix #19254
// defer testServer.Close() // defer testServer.Close()
client := client.NewOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}}) client := clientset.NewForConfigOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}})
endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc) endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc)
addPods(endpoints.podStore.Store, ns, 0, 1, 1) addPods(endpoints.podStore.Store, ns, 0, 1, 1)
endpoints.serviceStore.Store.Add(&api.Service{ endpoints.serviceStore.Store.Add(&api.Service{
@@ -323,7 +324,7 @@ func TestSyncEndpointsItemsEmptySelectorSelectsAllMixed(t *testing.T) {
}}) }})
// TODO: Uncomment when fix #19254 // TODO: Uncomment when fix #19254
// defer testServer.Close() // defer testServer.Close()
client := client.NewOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}}) client := clientset.NewForConfigOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}})
endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc) endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc)
addPods(endpoints.podStore.Store, ns, 1, 1, 1) addPods(endpoints.podStore.Store, ns, 1, 1, 1)
endpoints.serviceStore.Store.Add(&api.Service{ endpoints.serviceStore.Store.Add(&api.Service{
@@ -365,7 +366,7 @@ func TestSyncEndpointsItemsPreexisting(t *testing.T) {
}}) }})
// TODO: Uncomment when fix #19254 // TODO: Uncomment when fix #19254
// defer testServer.Close() // defer testServer.Close()
client := client.NewOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}}) client := clientset.NewForConfigOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}})
endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc) endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc)
addPods(endpoints.podStore.Store, ns, 1, 1, 0) addPods(endpoints.podStore.Store, ns, 1, 1, 0)
endpoints.serviceStore.Store.Add(&api.Service{ endpoints.serviceStore.Store.Add(&api.Service{
@@ -406,7 +407,7 @@ func TestSyncEndpointsItemsPreexistingIdentical(t *testing.T) {
}}) }})
// TODO: Uncomment when fix #19254 // TODO: Uncomment when fix #19254
// defer testServer.Close() // defer testServer.Close()
client := client.NewOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}}) client := clientset.NewForConfigOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}})
endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc) endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc)
addPods(endpoints.podStore.Store, api.NamespaceDefault, 1, 1, 0) addPods(endpoints.podStore.Store, api.NamespaceDefault, 1, 1, 0)
endpoints.serviceStore.Store.Add(&api.Service{ endpoints.serviceStore.Store.Add(&api.Service{
@@ -426,7 +427,7 @@ func TestSyncEndpointsItems(t *testing.T) {
serverResponse{http.StatusOK, &api.Endpoints{}}) serverResponse{http.StatusOK, &api.Endpoints{}})
// TODO: Uncomment when fix #19254 // TODO: Uncomment when fix #19254
// defer testServer.Close() // defer testServer.Close()
client := client.NewOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}}) client := clientset.NewForConfigOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}})
endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc) endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc)
addPods(endpoints.podStore.Store, ns, 3, 2, 0) addPods(endpoints.podStore.Store, ns, 3, 2, 0)
addPods(endpoints.podStore.Store, "blah", 5, 2, 0) // make sure these aren't found! addPods(endpoints.podStore.Store, "blah", 5, 2, 0) // make sure these aren't found!
@@ -469,7 +470,7 @@ func TestSyncEndpointsItemsWithLabels(t *testing.T) {
serverResponse{http.StatusOK, &api.Endpoints{}}) serverResponse{http.StatusOK, &api.Endpoints{}})
// TODO: Uncomment when fix #19254 // TODO: Uncomment when fix #19254
// defer testServer.Close() // defer testServer.Close()
client := client.NewOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}}) client := clientset.NewForConfigOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}})
endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc) endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc)
addPods(endpoints.podStore.Store, ns, 3, 2, 0) addPods(endpoints.podStore.Store, ns, 3, 2, 0)
serviceLabels := map[string]string{"foo": "bar"} serviceLabels := map[string]string{"foo": "bar"}
@@ -530,7 +531,7 @@ func TestSyncEndpointsItemsPreexistingLabelsChange(t *testing.T) {
}}) }})
// TODO: Uncomment when fix #19254 // TODO: Uncomment when fix #19254
// defer testServer.Close() // defer testServer.Close()
client := client.NewOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}}) client := clientset.NewForConfigOrDie(&client.Config{Host: testServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}})
endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc) endpoints := NewEndpointController(client, controller.NoResyncPeriodFunc)
addPods(endpoints.podStore.Store, ns, 1, 1, 0) addPods(endpoints.podStore.Store, ns, 1, 1, 0)
serviceLabels := map[string]string{"baz": "blah"} serviceLabels := map[string]string{"baz": "blah"}

12
pkg/controller/gc/gc_controller.go
View File

@@ -23,7 +23,7 @@ import (
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/client/cache" "k8s.io/kubernetes/pkg/client/cache"
client "k8s.io/kubernetes/pkg/client/unversioned" clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
"k8s.io/kubernetes/pkg/controller" "k8s.io/kubernetes/pkg/controller"
"k8s.io/kubernetes/pkg/controller/framework" "k8s.io/kubernetes/pkg/controller/framework"
"k8s.io/kubernetes/pkg/fields" "k8s.io/kubernetes/pkg/fields"
@@ -41,19 +41,19 @@ const (
) )
type GCController struct { type GCController struct {
kubeClient client.Interface kubeClient clientset.Interface
podStore cache.StoreToPodLister podStore cache.StoreToPodLister
podStoreSyncer *framework.Controller podStoreSyncer *framework.Controller
deletePod func(namespace, name string) error deletePod func(namespace, name string) error
threshold int threshold int
} }
func New(kubeClient client.Interface, resyncPeriod controller.ResyncPeriodFunc, threshold int) *GCController { func New(kubeClient clientset.Interface, resyncPeriod controller.ResyncPeriodFunc, threshold int) *GCController {
gcc := &GCController{ gcc := &GCController{
kubeClient: kubeClient, kubeClient: kubeClient,
threshold: threshold, threshold: threshold,
deletePod: func(namespace, name string) error { deletePod: func(namespace, name string) error {
return kubeClient.Pods(namespace).Delete(name, api.NewDeleteOptions(0)) return kubeClient.Legacy().Pods(namespace).Delete(name, api.NewDeleteOptions(0))
}, },
} }
@@ -63,11 +63,11 @@ func New(kubeClient client.Interface, resyncPeriod controller.ResyncPeriodFunc,
&cache.ListWatch{ &cache.ListWatch{
ListFunc: func(options api.ListOptions) (runtime.Object, error) { ListFunc: func(options api.ListOptions) (runtime.Object, error) {
options.FieldSelector = terminatedSelector options.FieldSelector = terminatedSelector
return gcc.kubeClient.Pods(api.NamespaceAll).List(options) return gcc.kubeClient.Legacy().Pods(api.NamespaceAll).List(options)
}, },
WatchFunc: func(options api.ListOptions) (watch.Interface, error) { WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
options.FieldSelector = terminatedSelector options.FieldSelector = terminatedSelector
return gcc.kubeClient.Pods(api.NamespaceAll).Watch(options) return gcc.kubeClient.Legacy().Pods(api.NamespaceAll).Watch(options)
}, },
}, },
&api.Pod{}, &api.Pod{},

4
pkg/controller/gc/gc_controller_test.go
View File

@@ -23,7 +23,7 @@ import (
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/client/unversioned/testclient" "k8s.io/kubernetes/pkg/client/testing/fake"
"k8s.io/kubernetes/pkg/controller" "k8s.io/kubernetes/pkg/controller"
"k8s.io/kubernetes/pkg/util/sets" "k8s.io/kubernetes/pkg/util/sets"
) )
@@ -66,7 +66,7 @@ func TestGC(t *testing.T) {
} }
for i, test := range testCases { for i, test := range testCases {
client := testclient.NewSimpleFake() client := fake.NewSimpleClientset()
gcc := New(client, controller.NoResyncPeriodFunc, test.threshold) gcc := New(client, controller.NoResyncPeriodFunc, test.threshold)
deletedPodNames := make([]string, 0) deletedPodNames := make([]string, 0)
var lock sync.Mutex var lock sync.Mutex

101
pkg/controller/namespace/namespace_controller.go
View File

@@ -24,7 +24,8 @@ import (
"k8s.io/kubernetes/pkg/api/errors" "k8s.io/kubernetes/pkg/api/errors"
"k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/client/cache" "k8s.io/kubernetes/pkg/client/cache"
client "k8s.io/kubernetes/pkg/client/unversioned" clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
extensions_unversioned "k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned"
"k8s.io/kubernetes/pkg/controller/framework" "k8s.io/kubernetes/pkg/controller/framework"
"k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/runtime"
utilruntime "k8s.io/kubernetes/pkg/util/runtime" utilruntime "k8s.io/kubernetes/pkg/util/runtime"
@@ -41,15 +42,15 @@ type NamespaceController struct {
} }
// NewNamespaceController creates a new NamespaceController // NewNamespaceController creates a new NamespaceController
func NewNamespaceController(kubeClient client.Interface, versions *unversioned.APIVersions, resyncPeriod time.Duration) *NamespaceController { func NewNamespaceController(kubeClient clientset.Interface, versions *unversioned.APIVersions, resyncPeriod time.Duration) *NamespaceController {
var controller *framework.Controller var controller *framework.Controller
_, controller = framework.NewInformer( _, controller = framework.NewInformer(
&cache.ListWatch{ &cache.ListWatch{
ListFunc: func(options api.ListOptions) (runtime.Object, error) { ListFunc: func(options api.ListOptions) (runtime.Object, error) {
return kubeClient.Namespaces().List(options) return kubeClient.Legacy().Namespaces().List(options)
}, },
WatchFunc: func(options api.ListOptions) (watch.Interface, error) { WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
return kubeClient.Namespaces().Watch(options) return kubeClient.Legacy().Namespaces().Watch(options)
}, },
}, },
&api.Namespace{}, &api.Namespace{},
@@ -125,7 +126,7 @@ func finalized(namespace *api.Namespace) bool {
} }
// finalize will finalize the namespace for kubernetes // finalize will finalize the namespace for kubernetes
func finalizeNamespaceFunc(kubeClient client.Interface, namespace *api.Namespace) (*api.Namespace, error) { func finalizeNamespaceFunc(kubeClient clientset.Interface, namespace *api.Namespace) (*api.Namespace, error) {
namespaceFinalize := api.Namespace{} namespaceFinalize := api.Namespace{}
namespaceFinalize.ObjectMeta = namespace.ObjectMeta namespaceFinalize.ObjectMeta = namespace.ObjectMeta
namespaceFinalize.Spec = namespace.Spec namespaceFinalize.Spec = namespace.Spec
@@ -139,7 +140,7 @@ func finalizeNamespaceFunc(kubeClient client.Interface, namespace *api.Namespace
for _, value := range finalizerSet.List() { for _, value := range finalizerSet.List() {
namespaceFinalize.Spec.Finalizers = append(namespaceFinalize.Spec.Finalizers, api.FinalizerName(value)) namespaceFinalize.Spec.Finalizers = append(namespaceFinalize.Spec.Finalizers, api.FinalizerName(value))
} }
namespace, err := kubeClient.Namespaces().Finalize(&namespaceFinalize) namespace, err := kubeClient.Legacy().Namespaces().Finalize(&namespaceFinalize)
if err != nil { if err != nil {
// it was removed already, so life is good // it was removed already, so life is good
if errors.IsNotFound(err) { if errors.IsNotFound(err) {
@@ -160,7 +161,7 @@ func (e *contentRemainingError) Error() string {
// deleteAllContent will delete all content known to the system in a namespace. It returns an estimate // deleteAllContent will delete all content known to the system in a namespace. It returns an estimate
// of the time remaining before the remaining resources are deleted. If estimate > 0 not all resources // of the time remaining before the remaining resources are deleted. If estimate > 0 not all resources
// are guaranteed to be gone. // are guaranteed to be gone.
func deleteAllContent(kubeClient client.Interface, versions *unversioned.APIVersions, namespace string, before unversioned.Time) (estimate int64, err error) { func deleteAllContent(kubeClient clientset.Interface, versions *unversioned.APIVersions, namespace string, before unversioned.Time) (estimate int64, err error) {
err = deleteServiceAccounts(kubeClient, namespace) err = deleteServiceAccounts(kubeClient, namespace)
if err != nil { if err != nil {
return estimate, err return estimate, err
@@ -238,11 +239,11 @@ func deleteAllContent(kubeClient client.Interface, versions *unversioned.APIVers
} }
// updateNamespaceFunc is a function that makes an update to a namespace // updateNamespaceFunc is a function that makes an update to a namespace
type updateNamespaceFunc func(kubeClient client.Interface, namespace *api.Namespace) (*api.Namespace, error) type updateNamespaceFunc func(kubeClient clientset.Interface, namespace *api.Namespace) (*api.Namespace, error)
// retryOnConflictError retries the specified fn if there was a conflict error // retryOnConflictError retries the specified fn if there was a conflict error
// TODO RetryOnConflict should be a generic concept in client code // TODO RetryOnConflict should be a generic concept in client code
func retryOnConflictError(kubeClient client.Interface, namespace *api.Namespace, fn updateNamespaceFunc) (result *api.Namespace, err error) { func retryOnConflictError(kubeClient clientset.Interface, namespace *api.Namespace, fn updateNamespaceFunc) (result *api.Namespace, err error) {
latestNamespace := namespace latestNamespace := namespace
for { for {
result, err = fn(kubeClient, latestNamespace) result, err = fn(kubeClient, latestNamespace)
@@ -252,7 +253,7 @@ func retryOnConflictError(kubeClient client.Interface, namespace *api.Namespace,
if !errors.IsConflict(err) { if !errors.IsConflict(err) {
return nil, err return nil, err
} }
latestNamespace, err = kubeClient.Namespaces().Get(latestNamespace.Name) latestNamespace, err = kubeClient.Legacy().Namespaces().Get(latestNamespace.Name)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -261,7 +262,7 @@ func retryOnConflictError(kubeClient client.Interface, namespace *api.Namespace,
} }
// updateNamespaceStatusFunc will verify that the status of the namespace is correct // updateNamespaceStatusFunc will verify that the status of the namespace is correct
func updateNamespaceStatusFunc(kubeClient client.Interface, namespace *api.Namespace) (*api.Namespace, error) { func updateNamespaceStatusFunc(kubeClient clientset.Interface, namespace *api.Namespace) (*api.Namespace, error) {
if namespace.DeletionTimestamp.IsZero() || namespace.Status.Phase == api.NamespaceTerminating { if namespace.DeletionTimestamp.IsZero() || namespace.Status.Phase == api.NamespaceTerminating {
return namespace, nil return namespace, nil
} }
@@ -269,11 +270,11 @@ func updateNamespaceStatusFunc(kubeClient client.Interface, namespace *api.Names
newNamespace.ObjectMeta = namespace.ObjectMeta newNamespace.ObjectMeta = namespace.ObjectMeta
newNamespace.Status = namespace.Status newNamespace.Status = namespace.Status
newNamespace.Status.Phase = api.NamespaceTerminating newNamespace.Status.Phase = api.NamespaceTerminating
return kubeClient.Namespaces().Status(&newNamespace) return kubeClient.Legacy().Namespaces().UpdateStatus(&newNamespace)
} }
// syncNamespace orchestrates deletion of a Namespace and its associated content. // syncNamespace orchestrates deletion of a Namespace and its associated content.
func syncNamespace(kubeClient client.Interface, versions *unversioned.APIVersions, namespace *api.Namespace) error { func syncNamespace(kubeClient clientset.Interface, versions *unversioned.APIVersions, namespace *api.Namespace) error {
if namespace.DeletionTimestamp == nil { if namespace.DeletionTimestamp == nil {
return nil return nil
} }
@@ -281,7 +282,7 @@ func syncNamespace(kubeClient client.Interface, versions *unversioned.APIVersion
// multiple controllers may edit a namespace during termination // multiple controllers may edit a namespace during termination
// first get the latest state of the namespace before proceeding // first get the latest state of the namespace before proceeding
// if the namespace was deleted already, don't do anything // if the namespace was deleted already, don't do anything
namespace, err := kubeClient.Namespaces().Get(namespace.Name) namespace, err := kubeClient.Legacy().Namespaces().Get(namespace.Name)
if err != nil { if err != nil {
if errors.IsNotFound(err) { if errors.IsNotFound(err) {
return nil return nil
@@ -303,7 +304,7 @@ func syncNamespace(kubeClient client.Interface, versions *unversioned.APIVersion
// if the namespace is already finalized, delete it // if the namespace is already finalized, delete it
if finalized(namespace) { if finalized(namespace) {
err = kubeClient.Namespaces().Delete(namespace.Name) err = kubeClient.Legacy().Namespaces().Delete(namespace.Name, nil)
if err != nil && !errors.IsNotFound(err) { if err != nil && !errors.IsNotFound(err) {
return err return err
} }
@@ -327,7 +328,7 @@ func syncNamespace(kubeClient client.Interface, versions *unversioned.APIVersion
// now check if all finalizers have reported that we delete now // now check if all finalizers have reported that we delete now
if finalized(result) { if finalized(result) {
err = kubeClient.Namespaces().Delete(namespace.Name) err = kubeClient.Legacy().Namespaces().Delete(namespace.Name, nil)
if err != nil && !errors.IsNotFound(err) { if err != nil && !errors.IsNotFound(err) {
return err return err
} }
@@ -336,13 +337,13 @@ func syncNamespace(kubeClient client.Interface, versions *unversioned.APIVersion
return nil return nil
} }
func deleteLimitRanges(kubeClient client.Interface, ns string) error { func deleteLimitRanges(kubeClient clientset.Interface, ns string) error {
items, err := kubeClient.LimitRanges(ns).List(api.ListOptions{}) items, err := kubeClient.Legacy().LimitRanges(ns).List(api.ListOptions{})
if err != nil { if err != nil {
return err return err
} }
for i := range items.Items { for i := range items.Items {
err := kubeClient.LimitRanges(ns).Delete(items.Items[i].Name) err := kubeClient.Legacy().LimitRanges(ns).Delete(items.Items[i].Name, nil)
if err != nil && !errors.IsNotFound(err) { if err != nil && !errors.IsNotFound(err) {
return err return err
} }
@@ -350,13 +351,13 @@ func deleteLimitRanges(kubeClient client.Interface, ns string) error {
return nil return nil
} }
func deleteResourceQuotas(kubeClient client.Interface, ns string) error { func deleteResourceQuotas(kubeClient clientset.Interface, ns string) error {
resourceQuotas, err := kubeClient.ResourceQuotas(ns).List(api.ListOptions{}) resourceQuotas, err := kubeClient.Legacy().ResourceQuotas(ns).List(api.ListOptions{})
if err != nil { if err != nil {
return err return err
} }
for i := range resourceQuotas.Items { for i := range resourceQuotas.Items {
err := kubeClient.ResourceQuotas(ns).Delete(resourceQuotas.Items[i].Name) err := kubeClient.Legacy().ResourceQuotas(ns).Delete(resourceQuotas.Items[i].Name, nil)
if err != nil && !errors.IsNotFound(err) { if err != nil && !errors.IsNotFound(err) {
return err return err
} }
@@ -364,13 +365,13 @@ func deleteResourceQuotas(kubeClient client.Interface, ns string) error {
return nil return nil
} }
func deleteServiceAccounts(kubeClient client.Interface, ns string) error { func deleteServiceAccounts(kubeClient clientset.Interface, ns string) error {
items, err := kubeClient.ServiceAccounts(ns).List(api.ListOptions{}) items, err := kubeClient.Legacy().ServiceAccounts(ns).List(api.ListOptions{})
if err != nil { if err != nil {
return err return err
} }
for i := range items.Items { for i := range items.Items {
err := kubeClient.ServiceAccounts(ns).Delete(items.Items[i].Name) err := kubeClient.Legacy().ServiceAccounts(ns).Delete(items.Items[i].Name, nil)
if err != nil && !errors.IsNotFound(err) { if err != nil && !errors.IsNotFound(err) {
return err return err
} }
@@ -378,13 +379,13 @@ func deleteServiceAccounts(kubeClient client.Interface, ns string) error {
return nil return nil
} }
func deleteServices(kubeClient client.Interface, ns string) error { func deleteServices(kubeClient clientset.Interface, ns string) error {
items, err := kubeClient.Services(ns).List(api.ListOptions{}) items, err := kubeClient.Legacy().Services(ns).List(api.ListOptions{})
if err != nil { if err != nil {
return err return err
} }
for i := range items.Items { for i := range items.Items {
err := kubeClient.Services(ns).Delete(items.Items[i].Name) err := kubeClient.Legacy().Services(ns).Delete(items.Items[i].Name, nil)
if err != nil && !errors.IsNotFound(err) { if err != nil && !errors.IsNotFound(err) {
return err return err
} }
@@ -392,13 +393,13 @@ func deleteServices(kubeClient client.Interface, ns string) error {
return nil return nil
} }
func deleteReplicationControllers(kubeClient client.Interface, ns string) error { func deleteReplicationControllers(kubeClient clientset.Interface, ns string) error {
items, err := kubeClient.ReplicationControllers(ns).List(api.ListOptions{}) items, err := kubeClient.Legacy().ReplicationControllers(ns).List(api.ListOptions{})
if err != nil { if err != nil {
return err return err
} }
for i := range items.Items { for i := range items.Items {
err := kubeClient.ReplicationControllers(ns).Delete(items.Items[i].Name) err := kubeClient.Legacy().ReplicationControllers(ns).Delete(items.Items[i].Name, nil)
if err != nil && !errors.IsNotFound(err) { if err != nil && !errors.IsNotFound(err) {
return err return err
} }
@@ -406,8 +407,8 @@ func deleteReplicationControllers(kubeClient client.Interface, ns string) error
return nil return nil
} }
func deletePods(kubeClient client.Interface, ns string, before unversioned.Time) (int64, error) { func deletePods(kubeClient clientset.Interface, ns string, before unversioned.Time) (int64, error) {
items, err := kubeClient.Pods(ns).List(api.ListOptions{}) items, err := kubeClient.Legacy().Pods(ns).List(api.ListOptions{})
if err != nil { if err != nil {
return 0, err return 0, err
} }
@@ -424,7 +425,7 @@ func deletePods(kubeClient client.Interface, ns string, before unversioned.Time)
estimate = grace estimate = grace
} }
} }
err := kubeClient.Pods(ns).Delete(items.Items[i].Name, deleteOptions) err := kubeClient.Legacy().Pods(ns).Delete(items.Items[i].Name, deleteOptions)
if err != nil && !errors.IsNotFound(err) { if err != nil && !errors.IsNotFound(err) {
return 0, err return 0, err
} }
@@ -435,17 +436,17 @@ func deletePods(kubeClient client.Interface, ns string, before unversioned.Time)
return estimate, nil return estimate, nil
} }
func deleteEvents(kubeClient client.Interface, ns string) error { func deleteEvents(kubeClient clientset.Interface, ns string) error {
return kubeClient.Events(ns).DeleteCollection(nil, api.ListOptions{}) return kubeClient.Legacy().Events(ns).DeleteCollection(nil, api.ListOptions{})
} }
func deleteSecrets(kubeClient client.Interface, ns string) error { func deleteSecrets(kubeClient clientset.Interface, ns string) error {
items, err := kubeClient.Secrets(ns).List(api.ListOptions{}) items, err := kubeClient.Legacy().Secrets(ns).List(api.ListOptions{})
if err != nil { if err != nil {
return err return err
} }
for i := range items.Items { for i := range items.Items {
err := kubeClient.Secrets(ns).Delete(items.Items[i].Name) err := kubeClient.Legacy().Secrets(ns).Delete(items.Items[i].Name, nil)
if err != nil && !errors.IsNotFound(err) { if err != nil && !errors.IsNotFound(err) {
return err return err
} }
@@ -453,13 +454,13 @@ func deleteSecrets(kubeClient client.Interface, ns string) error {
return nil return nil
} }
func deletePersistentVolumeClaims(kubeClient client.Interface, ns string) error { func deletePersistentVolumeClaims(kubeClient clientset.Interface, ns string) error {
items, err := kubeClient.PersistentVolumeClaims(ns).List(api.ListOptions{}) items, err := kubeClient.Legacy().PersistentVolumeClaims(ns).List(api.ListOptions{})
if err != nil { if err != nil {
return err return err
} }
for i := range items.Items { for i := range items.Items {
err := kubeClient.PersistentVolumeClaims(ns).Delete(items.Items[i].Name) err := kubeClient.Legacy().PersistentVolumeClaims(ns).Delete(items.Items[i].Name, nil)
if err != nil && !errors.IsNotFound(err) { if err != nil && !errors.IsNotFound(err) {
return err return err
} }
@@ -467,7 +468,7 @@ func deletePersistentVolumeClaims(kubeClient client.Interface, ns string) error
return nil return nil
} }
func deleteHorizontalPodAutoscalers(expClient client.ExtensionsInterface, ns string) error { func deleteHorizontalPodAutoscalers(expClient extensions_unversioned.ExtensionsInterface, ns string) error {
items, err := expClient.HorizontalPodAutoscalers(ns).List(api.ListOptions{}) items, err := expClient.HorizontalPodAutoscalers(ns).List(api.ListOptions{})
if err != nil { if err != nil {
return err return err
@@ -481,13 +482,13 @@ func deleteHorizontalPodAutoscalers(expClient client.ExtensionsInterface, ns str
return nil return nil
} }
func deleteDaemonSets(expClient client.ExtensionsInterface, ns string) error { func deleteDaemonSets(expClient extensions_unversioned.ExtensionsInterface, ns string) error {
items, err := expClient.DaemonSets(ns).List(api.ListOptions{}) items, err := expClient.DaemonSets(ns).List(api.ListOptions{})
if err != nil { if err != nil {
return err return err
} }
for i := range items.Items { for i := range items.Items {
err := expClient.DaemonSets(ns).Delete(items.Items[i].Name) err := expClient.DaemonSets(ns).Delete(items.Items[i].Name, nil)
if err != nil && !errors.IsNotFound(err) { if err != nil && !errors.IsNotFound(err) {
return err return err
} }
@@ -495,7 +496,7 @@ func deleteDaemonSets(expClient client.ExtensionsInterface, ns string) error {
return nil return nil
} }
func deleteJobs(expClient client.ExtensionsInterface, ns string) error { func deleteJobs(expClient extensions_unversioned.ExtensionsInterface, ns string) error {
items, err := expClient.Jobs(ns).List(api.ListOptions{}) items, err := expClient.Jobs(ns).List(api.ListOptions{})
if err != nil { if err != nil {
return err return err
@@ -509,7 +510,7 @@ func deleteJobs(expClient client.ExtensionsInterface, ns string) error {
return nil return nil
} }
func deleteDeployments(expClient client.ExtensionsInterface, ns string) error { func deleteDeployments(expClient extensions_unversioned.ExtensionsInterface, ns string) error {
items, err := expClient.Deployments(ns).List(api.ListOptions{}) items, err := expClient.Deployments(ns).List(api.ListOptions{})
if err != nil { if err != nil {
return err return err
@@ -523,13 +524,13 @@ func deleteDeployments(expClient client.ExtensionsInterface, ns string) error {
return nil return nil
} }
func deleteIngress(expClient client.ExtensionsInterface, ns string) error { func deleteIngress(expClient extensions_unversioned.ExtensionsInterface, ns string) error {
items, err := expClient.Ingress(ns).List(api.ListOptions{}) items, err := expClient.Ingresses(ns).List(api.ListOptions{})
if err != nil { if err != nil {
return err return err
} }
for i := range items.Items { for i := range items.Items {
err := expClient.Ingress(ns).Delete(items.Items[i].Name, nil) err := expClient.Ingresses(ns).Delete(items.Items[i].Name, nil)
if err != nil && !errors.IsNotFound(err) { if err != nil && !errors.IsNotFound(err) {
return err return err
} }

19
pkg/controller/namespace/namespace_controller_test.go
View File

@@ -25,8 +25,9 @@ import (
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/errors" "k8s.io/kubernetes/pkg/api/errors"
"k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/unversioned"
client "k8s.io/kubernetes/pkg/client/unversioned" clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
"k8s.io/kubernetes/pkg/client/unversioned/testclient" "k8s.io/kubernetes/pkg/client/testing/core"
"k8s.io/kubernetes/pkg/client/testing/fake"
"k8s.io/kubernetes/pkg/util/sets" "k8s.io/kubernetes/pkg/util/sets"
) )
@@ -46,7 +47,7 @@ func TestFinalized(t *testing.T) {
} }
func TestFinalizeNamespaceFunc(t *testing.T) { func TestFinalizeNamespaceFunc(t *testing.T) {
mockClient := &testclient.Fake{} mockClient := &fake.Clientset{}
testNamespace := &api.Namespace{ testNamespace := &api.Namespace{
ObjectMeta: api.ObjectMeta{ ObjectMeta: api.ObjectMeta{
Name: "test", Name: "test",
@@ -64,7 +65,7 @@ func TestFinalizeNamespaceFunc(t *testing.T) {
if !actions[0].Matches("create", "namespaces") || actions[0].GetSubresource() != "finalize" { if !actions[0].Matches("create", "namespaces") || actions[0].GetSubresource() != "finalize" {
t.Errorf("Expected finalize-namespace action %v", actions[0]) t.Errorf("Expected finalize-namespace action %v", actions[0])
} }
finalizers := actions[0].(testclient.CreateAction).GetObject().(*api.Namespace).Spec.Finalizers finalizers := actions[0].(core.CreateAction).GetObject().(*api.Namespace).Spec.Finalizers
if len(finalizers) != 1 { if len(finalizers) != 1 {
t.Errorf("There should be a single finalizer remaining") t.Errorf("There should be a single finalizer remaining")
} }
@@ -144,7 +145,7 @@ func testSyncNamespaceThatIsTerminating(t *testing.T, versions *unversioned.APIV
} }
for scenario, testInput := range scenarios { for scenario, testInput := range scenarios {
mockClient := testclient.NewSimpleFake(testInput.testNamespace) mockClient := fake.NewSimpleClientset(testInput.testNamespace)
if containsVersion(versions, "extensions/v1beta1") { if containsVersion(versions, "extensions/v1beta1") {
resources := []unversioned.APIResource{} resources := []unversioned.APIResource{}
for _, resource := range []string{"daemonsets", "deployments", "jobs", "horizontalpodautoscalers", "ingresses"} { for _, resource := range []string{"daemonsets", "deployments", "jobs", "horizontalpodautoscalers", "ingresses"} {
@@ -175,9 +176,9 @@ func testSyncNamespaceThatIsTerminating(t *testing.T, versions *unversioned.APIV
} }
func TestRetryOnConflictError(t *testing.T) { func TestRetryOnConflictError(t *testing.T) {
mockClient := &testclient.Fake{} mockClient := &fake.Clientset{}
numTries := 0 numTries := 0
retryOnce := func(kubeClient client.Interface, namespace *api.Namespace) (*api.Namespace, error) { retryOnce := func(kubeClient clientset.Interface, namespace *api.Namespace) (*api.Namespace, error) {
numTries++ numTries++
if numTries <= 1 { if numTries <= 1 {
return namespace, errors.NewConflict(api.Resource("namespaces"), namespace.Name, fmt.Errorf("ERROR!")) return namespace, errors.NewConflict(api.Resource("namespaces"), namespace.Name, fmt.Errorf("ERROR!"))
@@ -203,7 +204,7 @@ func TestSyncNamespaceThatIsTerminatingV1Beta1(t *testing.T) {
} }
func TestSyncNamespaceThatIsActive(t *testing.T) { func TestSyncNamespaceThatIsActive(t *testing.T) {
mockClient := &testclient.Fake{} mockClient := &fake.Clientset{}
testNamespace := &api.Namespace{ testNamespace := &api.Namespace{
ObjectMeta: api.ObjectMeta{ ObjectMeta: api.ObjectMeta{
Name: "test", Name: "test",
@@ -226,7 +227,7 @@ func TestSyncNamespaceThatIsActive(t *testing.T) {
} }
func TestRunStop(t *testing.T) { func TestRunStop(t *testing.T) {
mockClient := &testclient.Fake{} mockClient := &fake.Clientset{}
nsController := NewNamespaceController(mockClient, &unversioned.APIVersions{}, 1*time.Second) nsController := NewNamespaceController(mockClient, &unversioned.APIVersions{}, 1*time.Second)

44
pkg/controller/node/nodecontroller.go
View File

@@ -28,7 +28,9 @@ import (
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/client/cache" "k8s.io/kubernetes/pkg/client/cache"
clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
"k8s.io/kubernetes/pkg/client/record" "k8s.io/kubernetes/pkg/client/record"
unversioned_legacy "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
client "k8s.io/kubernetes/pkg/client/unversioned" client "k8s.io/kubernetes/pkg/client/unversioned"
"k8s.io/kubernetes/pkg/cloudprovider" "k8s.io/kubernetes/pkg/cloudprovider"
"k8s.io/kubernetes/pkg/controller" "k8s.io/kubernetes/pkg/controller"
@@ -67,7 +69,7 @@ type NodeController struct {
clusterCIDR *net.IPNet clusterCIDR *net.IPNet
deletingPodsRateLimiter util.RateLimiter deletingPodsRateLimiter util.RateLimiter
knownNodeSet sets.String knownNodeSet sets.String
kubeClient client.Interface kubeClient clientset.Interface
// Method for easy mocking in unittest. // Method for easy mocking in unittest.
lookupIP func(host string) ([]net.IP, error) lookupIP func(host string) ([]net.IP, error)
// Value used if sync_nodes_status=False. NodeController will not proactively // Value used if sync_nodes_status=False. NodeController will not proactively
@@ -122,7 +124,7 @@ type NodeController struct {
// NewNodeController returns a new node controller to sync instances from cloudprovider. // NewNodeController returns a new node controller to sync instances from cloudprovider.
func NewNodeController( func NewNodeController(
cloud cloudprovider.Interface, cloud cloudprovider.Interface,
kubeClient client.Interface, kubeClient clientset.Interface,
podEvictionTimeout time.Duration, podEvictionTimeout time.Duration,
deletionEvictionLimiter util.RateLimiter, deletionEvictionLimiter util.RateLimiter,
terminationEvictionLimiter util.RateLimiter, terminationEvictionLimiter util.RateLimiter,
@@ -136,7 +138,7 @@ func NewNodeController(
eventBroadcaster.StartLogging(glog.Infof) eventBroadcaster.StartLogging(glog.Infof)
if kubeClient != nil { if kubeClient != nil {
glog.Infof("Sending events to api server.") glog.Infof("Sending events to api server.")
eventBroadcaster.StartRecordingToSink(kubeClient.Events("")) eventBroadcaster.StartRecordingToSink(&unversioned_legacy.EventSinkImpl{kubeClient.Legacy().Events("")})
} else { } else {
glog.Infof("No api server defined - no events will be sent to API server.") glog.Infof("No api server defined - no events will be sent to API server.")
} }
@@ -169,10 +171,10 @@ func NewNodeController(
nc.podStore.Store, nc.podController = framework.NewInformer( nc.podStore.Store, nc.podController = framework.NewInformer(
&cache.ListWatch{ &cache.ListWatch{
ListFunc: func(options api.ListOptions) (runtime.Object, error) { ListFunc: func(options api.ListOptions) (runtime.Object, error) {
return nc.kubeClient.Pods(api.NamespaceAll).List(options) return nc.kubeClient.Legacy().Pods(api.NamespaceAll).List(options)
}, },
WatchFunc: func(options api.ListOptions) (watch.Interface, error) { WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
return nc.kubeClient.Pods(api.NamespaceAll).Watch(options) return nc.kubeClient.Legacy().Pods(api.NamespaceAll).Watch(options)
}, },
}, },
&api.Pod{}, &api.Pod{},
@@ -185,10 +187,10 @@ func NewNodeController(
nc.nodeStore.Store, nc.nodeController = framework.NewInformer( nc.nodeStore.Store, nc.nodeController = framework.NewInformer(
&cache.ListWatch{ &cache.ListWatch{
ListFunc: func(options api.ListOptions) (runtime.Object, error) { ListFunc: func(options api.ListOptions) (runtime.Object, error) {
return nc.kubeClient.Nodes().List(options) return nc.kubeClient.Legacy().Nodes().List(options)
}, },
WatchFunc: func(options api.ListOptions) (watch.Interface, error) { WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
return nc.kubeClient.Nodes().Watch(options) return nc.kubeClient.Legacy().Nodes().Watch(options)
}, },
}, },
&api.Node{}, &api.Node{},
@@ -363,9 +365,9 @@ func (nc *NodeController) maybeDeleteTerminatingPod(obj interface{}) {
} }
} }
func forcefullyDeletePod(c client.Interface, pod *api.Pod) { func forcefullyDeletePod(c clientset.Interface, pod *api.Pod) {
var zero int64 var zero int64
err := c.Pods(pod.Namespace).Delete(pod.Name, &api.DeleteOptions{GracePeriodSeconds: &zero}) err := c.Legacy().Pods(pod.Namespace).Delete(pod.Name, &api.DeleteOptions{GracePeriodSeconds: &zero})
if err != nil { if err != nil {
utilruntime.HandleError(err) utilruntime.HandleError(err)
} }
@@ -375,7 +377,7 @@ func forcefullyDeletePod(c client.Interface, pod *api.Pod) {
// post "NodeReady==ConditionUnknown". It also evicts all pods if node is not ready or // post "NodeReady==ConditionUnknown". It also evicts all pods if node is not ready or
// not reachable for a long period of time. // not reachable for a long period of time.
func (nc *NodeController) monitorNodeStatus() error { func (nc *NodeController) monitorNodeStatus() error {
nodes, err := nc.kubeClient.Nodes().List(api.ListOptions{}) nodes, err := nc.kubeClient.Legacy().Nodes().List(api.ListOptions{})
if err != nil { if err != nil {
return err return err
} }
@@ -419,7 +421,7 @@ func (nc *NodeController) monitorNodeStatus() error {
break break
} }
name := node.Name name := node.Name
node, err = nc.kubeClient.Nodes().Get(name) node, err = nc.kubeClient.Legacy().Nodes().Get(name)
if err != nil { if err != nil {
glog.Errorf("Failed while getting a Node to retry updating NodeStatus. Probably Node %s was deleted.", name) glog.Errorf("Failed while getting a Node to retry updating NodeStatus. Probably Node %s was deleted.", name)
break break
@@ -485,7 +487,7 @@ func (nc *NodeController) monitorNodeStatus() error {
continue continue
} }
if err := nc.kubeClient.Nodes().Delete(node.Name); err != nil { if err := nc.kubeClient.Legacy().Nodes().Delete(node.Name, nil); err != nil {
glog.Errorf("Unable to delete node %s: %v", node.Name, err) glog.Errorf("Unable to delete node %s: %v", node.Name, err)
continue continue
} }
@@ -518,7 +520,7 @@ func (nc *NodeController) reconcileNodeCIDRs(nodes *api.NodeList) {
} }
glog.V(4).Infof("Assigning node %s CIDR %s", node.Name, podCIDR) glog.V(4).Infof("Assigning node %s CIDR %s", node.Name, podCIDR)
node.Spec.PodCIDR = podCIDR node.Spec.PodCIDR = podCIDR
if _, err := nc.kubeClient.Nodes().Update(&node); err != nil { if _, err := nc.kubeClient.Legacy().Nodes().Update(&node); err != nil {
nc.recordNodeStatusChange(&node, "CIDRAssignmentFailed") nc.recordNodeStatusChange(&node, "CIDRAssignmentFailed")
} }
} }
@@ -696,7 +698,7 @@ func (nc *NodeController) tryUpdateNodeStatus(node *api.Node) (time.Duration, ap
} }
if !api.Semantic.DeepEqual(nc.getCondition(&node.Status, api.NodeReady), &lastReadyCondition) { if !api.Semantic.DeepEqual(nc.getCondition(&node.Status, api.NodeReady), &lastReadyCondition) {
if _, err = nc.kubeClient.Nodes().UpdateStatus(node); err != nil { if _, err = nc.kubeClient.Legacy().Nodes().UpdateStatus(node); err != nil {
glog.Errorf("Error updating node %s: %v", node.Name, err) glog.Errorf("Error updating node %s: %v", node.Name, err)
return gracePeriod, lastReadyCondition, readyCondition, err return gracePeriod, lastReadyCondition, readyCondition, err
} else { } else {
@@ -718,7 +720,7 @@ func (nc *NodeController) tryUpdateNodeStatus(node *api.Node) (time.Duration, ap
func (nc *NodeController) hasPods(nodeName string) (bool, error) { func (nc *NodeController) hasPods(nodeName string) (bool, error) {
selector := fields.OneTermEqualSelector(client.PodHost, nodeName) selector := fields.OneTermEqualSelector(client.PodHost, nodeName)
options := api.ListOptions{FieldSelector: selector} options := api.ListOptions{FieldSelector: selector}
pods, err := nc.kubeClient.Pods(api.NamespaceAll).List(options) pods, err := nc.kubeClient.Legacy().Pods(api.NamespaceAll).List(options)
if err != nil { if err != nil {
return false, err return false, err
} }
@@ -753,7 +755,7 @@ func (nc *NodeController) deletePods(nodeName string) (bool, error) {
remaining := false remaining := false
selector := fields.OneTermEqualSelector(client.PodHost, nodeName) selector := fields.OneTermEqualSelector(client.PodHost, nodeName)
options := api.ListOptions{FieldSelector: selector} options := api.ListOptions{FieldSelector: selector}
pods, err := nc.kubeClient.Pods(api.NamespaceAll).List(options) pods, err := nc.kubeClient.Legacy().Pods(api.NamespaceAll).List(options)
if err != nil { if err != nil {
return remaining, err return remaining, err
} }
@@ -779,7 +781,7 @@ func (nc *NodeController) deletePods(nodeName string) (bool, error) {
glog.V(2).Infof("Starting deletion of pod %v", pod.Name) glog.V(2).Infof("Starting deletion of pod %v", pod.Name)
nc.recorder.Eventf(&pod, api.EventTypeNormal, "NodeControllerEviction", "Marking for deletion Pod %s from Node %s", pod.Name, nodeName) nc.recorder.Eventf(&pod, api.EventTypeNormal, "NodeControllerEviction", "Marking for deletion Pod %s from Node %s", pod.Name, nodeName)
if err := nc.kubeClient.Pods(pod.Namespace).Delete(pod.Name, nil); err != nil { if err := nc.kubeClient.Legacy().Pods(pod.Namespace).Delete(pod.Name, nil); err != nil {
return false, err return false, err
} }
remaining = true remaining = true
@@ -792,7 +794,7 @@ func (nc *NodeController) deletePods(nodeName string) (bool, error) {
func (nc *NodeController) markAllPodsNotReady(nodeName string) error { func (nc *NodeController) markAllPodsNotReady(nodeName string) error {
glog.V(2).Infof("Update ready status of pods on node [%v]", nodeName) glog.V(2).Infof("Update ready status of pods on node [%v]", nodeName)
opts := api.ListOptions{FieldSelector: fields.OneTermEqualSelector(client.PodHost, nodeName)} opts := api.ListOptions{FieldSelector: fields.OneTermEqualSelector(client.PodHost, nodeName)}
pods, err := nc.kubeClient.Pods(api.NamespaceAll).List(opts) pods, err := nc.kubeClient.Legacy().Pods(api.NamespaceAll).List(opts)
if err != nil { if err != nil {
return err return err
} }
@@ -808,7 +810,7 @@ func (nc *NodeController) markAllPodsNotReady(nodeName string) error {
if cond.Type == api.PodReady { if cond.Type == api.PodReady {
pod.Status.Conditions[i].Status = api.ConditionFalse pod.Status.Conditions[i].Status = api.ConditionFalse
glog.V(2).Infof("Updating ready status of pod %v to false", pod.Name) glog.V(2).Infof("Updating ready status of pod %v to false", pod.Name)
pod, err := nc.kubeClient.Pods(pod.Namespace).UpdateStatus(&pod) pod, err := nc.kubeClient.Legacy().Pods(pod.Namespace).UpdateStatus(&pod)
if err != nil { if err != nil {
glog.Warningf("Failed to updated status for pod %q: %v", format.Pod(pod), err) glog.Warningf("Failed to updated status for pod %q: %v", format.Pod(pod), err)
errMsg = append(errMsg, fmt.Sprintf("%v", err)) errMsg = append(errMsg, fmt.Sprintf("%v", err))
@@ -834,7 +836,7 @@ func (nc *NodeController) terminatePods(nodeName string, since time.Time) (bool,
selector := fields.OneTermEqualSelector(client.PodHost, nodeName) selector := fields.OneTermEqualSelector(client.PodHost, nodeName)
options := api.ListOptions{FieldSelector: selector} options := api.ListOptions{FieldSelector: selector}
pods, err := nc.kubeClient.Pods(api.NamespaceAll).List(options) pods, err := nc.kubeClient.Legacy().Pods(api.NamespaceAll).List(options)
if err != nil { if err != nil {
return false, nextAttempt, err return false, nextAttempt, err
} }
@@ -863,7 +865,7 @@ func (nc *NodeController) terminatePods(nodeName string, since time.Time) (bool,
remaining = 0 remaining = 0
glog.V(2).Infof("Removing pod %v after %s grace period", pod.Name, grace) glog.V(2).Infof("Removing pod %v after %s grace period", pod.Name, grace)
nc.recordNodeEvent(nodeName, api.EventTypeNormal, "TerminatingEvictedPod", fmt.Sprintf("Pod %s has exceeded the grace period for deletion after being evicted from Node %q and is being force killed", pod.Name, nodeName)) nc.recordNodeEvent(nodeName, api.EventTypeNormal, "TerminatingEvictedPod", fmt.Sprintf("Pod %s has exceeded the grace period for deletion after being evicted from Node %q and is being force killed", pod.Name, nodeName))
if err := nc.kubeClient.Pods(pod.Namespace).Delete(pod.Name, api.NewDeleteOptions(0)); err != nil { if err := nc.kubeClient.Legacy().Pods(pod.Namespace).Delete(pod.Name, api.NewDeleteOptions(0)); err != nil {
glog.Errorf("Error completing deletion of pod %s: %v", pod.Name, err) glog.Errorf("Error completing deletion of pod %s: %v", pod.Name, err)
complete = false complete = false
} }

55
pkg/controller/node/nodecontroller_test.go
View File

@@ -28,8 +28,8 @@ import (
"k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/apis/extensions" "k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/client/cache" "k8s.io/kubernetes/pkg/client/cache"
client "k8s.io/kubernetes/pkg/client/unversioned" "k8s.io/kubernetes/pkg/client/testing/fake"
"k8s.io/kubernetes/pkg/client/unversioned/testclient" unversioned_legacy "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
"k8s.io/kubernetes/pkg/util" "k8s.io/kubernetes/pkg/util"
"k8s.io/kubernetes/pkg/watch" "k8s.io/kubernetes/pkg/watch"
) )
@@ -45,7 +45,7 @@ const (
// PodsInterface and PodInterface to test list & delet pods, which is implemented in // PodsInterface and PodInterface to test list & delet pods, which is implemented in
// the embedded client.Fake field. // the embedded client.Fake field.
type FakeNodeHandler struct { type FakeNodeHandler struct {
*testclient.Fake *fake.Clientset
// Input: Hooks determine if request is valid or not // Input: Hooks determine if request is valid or not
CreateHook func(*FakeNodeHandler, *api.Node) bool CreateHook func(*FakeNodeHandler, *api.Node) bool
@@ -62,8 +62,17 @@ type FakeNodeHandler struct {
createLock sync.Mutex createLock sync.Mutex
} }
func (c *FakeNodeHandler) Nodes() client.NodeInterface { type FakeLegacyHandler struct {
return c unversioned_legacy.LegacyInterface
n *FakeNodeHandler
}
func (c *FakeNodeHandler) Legacy() unversioned_legacy.LegacyInterface {
return &FakeLegacyHandler{c.Clientset.Legacy(), c}
}
func (m *FakeLegacyHandler) Nodes() unversioned_legacy.NodeInterface {
return m.n
} }
func (m *FakeNodeHandler) Create(node *api.Node) (*api.Node, error) { func (m *FakeNodeHandler) Create(node *api.Node) (*api.Node, error) {
@@ -115,12 +124,16 @@ func (m *FakeNodeHandler) List(opts api.ListOptions) (*api.NodeList, error) {
return nodeList, nil return nodeList, nil
} }
func (m *FakeNodeHandler) Delete(id string) error { func (m *FakeNodeHandler) Delete(id string, opt *api.DeleteOptions) error {
m.DeletedNodes = append(m.DeletedNodes, newNode(id)) m.DeletedNodes = append(m.DeletedNodes, newNode(id))
m.RequestCount++ m.RequestCount++
return nil return nil
} }
func (m *FakeNodeHandler) DeleteCollection(opt *api.DeleteOptions, listOpts api.ListOptions) error {
return nil
}
func (m *FakeNodeHandler) Update(node *api.Node) (*api.Node, error) { func (m *FakeNodeHandler) Update(node *api.Node) (*api.Node, error) {
nodeCopy := *node nodeCopy := *node
m.UpdatedNodes = append(m.UpdatedNodes, &nodeCopy) m.UpdatedNodes = append(m.UpdatedNodes, &nodeCopy)
@@ -162,7 +175,7 @@ func TestMonitorNodeStatusEvictPods(t *testing.T) {
}, },
}, },
}, },
Fake: testclient.NewSimpleFake(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}), Clientset: fake.NewSimpleClientset(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}),
}, },
daemonSets: nil, daemonSets: nil,
timeToPass: 0, timeToPass: 0,
@@ -191,7 +204,7 @@ func TestMonitorNodeStatusEvictPods(t *testing.T) {
}, },
}, },
}, },
Fake: testclient.NewSimpleFake(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}), Clientset: fake.NewSimpleClientset(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}),
}, },
daemonSets: nil, daemonSets: nil,
timeToPass: evictionTimeout, timeToPass: evictionTimeout,
@@ -230,7 +243,7 @@ func TestMonitorNodeStatusEvictPods(t *testing.T) {
}, },
}, },
}, },
Fake: testclient.NewSimpleFake( Clientset: fake.NewSimpleClientset(
&api.PodList{ &api.PodList{
Items: []api.Pod{ Items: []api.Pod{
{ {
@@ -296,7 +309,7 @@ func TestMonitorNodeStatusEvictPods(t *testing.T) {
}, },
}, },
}, },
Fake: testclient.NewSimpleFake(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}), Clientset: fake.NewSimpleClientset(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}),
}, },
daemonSets: nil, daemonSets: nil,
timeToPass: time.Hour, timeToPass: time.Hour,
@@ -335,7 +348,7 @@ func TestMonitorNodeStatusEvictPods(t *testing.T) {
}, },
}, },
}, },
Fake: testclient.NewSimpleFake(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}), Clientset: fake.NewSimpleClientset(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}),
}, },
daemonSets: nil, daemonSets: nil,
timeToPass: evictionTimeout - testNodeMonitorGracePeriod, timeToPass: evictionTimeout - testNodeMonitorGracePeriod,
@@ -374,7 +387,7 @@ func TestMonitorNodeStatusEvictPods(t *testing.T) {
}, },
}, },
}, },
Fake: testclient.NewSimpleFake(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}), Clientset: fake.NewSimpleClientset(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}),
}, },
daemonSets: nil, daemonSets: nil,
timeToPass: 60 * time.Minute, timeToPass: 60 * time.Minute,
@@ -460,7 +473,7 @@ func TestMonitorNodeStatusUpdateStatus(t *testing.T) {
}, },
}, },
}, },
Fake: testclient.NewSimpleFake(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}), Clientset: fake.NewSimpleClientset(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}),
}, },
expectedRequestCount: 2, // List+Update expectedRequestCount: 2, // List+Update
expectedNodes: []*api.Node{ expectedNodes: []*api.Node{
@@ -504,7 +517,7 @@ func TestMonitorNodeStatusUpdateStatus(t *testing.T) {
}, },
}, },
}, },
Fake: testclient.NewSimpleFake(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}), Clientset: fake.NewSimpleClientset(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}),
}, },
expectedRequestCount: 1, // List expectedRequestCount: 1, // List
expectedNodes: nil, expectedNodes: nil,
@@ -546,7 +559,7 @@ func TestMonitorNodeStatusUpdateStatus(t *testing.T) {
}, },
}, },
}, },
Fake: testclient.NewSimpleFake(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}), Clientset: fake.NewSimpleClientset(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}),
}, },
expectedRequestCount: 3, // (List+)List+Update expectedRequestCount: 3, // (List+)List+Update
timeToPass: time.Hour, timeToPass: time.Hour,
@@ -638,7 +651,7 @@ func TestMonitorNodeStatusUpdateStatus(t *testing.T) {
}, },
}, },
}, },
Fake: testclient.NewSimpleFake(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}), Clientset: fake.NewSimpleClientset(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}),
}, },
expectedRequestCount: 1, // List expectedRequestCount: 1, // List
expectedNodes: nil, expectedNodes: nil,
@@ -691,7 +704,7 @@ func TestMonitorNodeStatusMarkPodsNotReady(t *testing.T) {
}, },
}, },
}, },
Fake: testclient.NewSimpleFake(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}), Clientset: fake.NewSimpleClientset(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}),
}, },
expectedPodStatusUpdate: false, expectedPodStatusUpdate: false,
}, },
@@ -725,7 +738,7 @@ func TestMonitorNodeStatusMarkPodsNotReady(t *testing.T) {
}, },
}, },
}, },
Fake: testclient.NewSimpleFake(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}), Clientset: fake.NewSimpleClientset(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}),
}, },
expectedPodStatusUpdate: false, expectedPodStatusUpdate: false,
}, },
@@ -766,7 +779,7 @@ func TestMonitorNodeStatusMarkPodsNotReady(t *testing.T) {
}, },
}, },
}, },
Fake: testclient.NewSimpleFake(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}), Clientset: fake.NewSimpleClientset(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0")}}),
}, },
timeToPass: 1 * time.Minute, timeToPass: 1 * time.Minute,
newNodeStatus: api.NodeStatus{ newNodeStatus: api.NodeStatus{
@@ -875,7 +888,7 @@ func TestNodeDeletion(t *testing.T) {
}, },
}, },
}, },
Fake: testclient.NewSimpleFake(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0"), *newPod("pod1", "node1")}}), Clientset: fake.NewSimpleClientset(&api.PodList{Items: []api.Pod{*newPod("pod0", "node0"), *newPod("pod1", "node1")}}),
} }
nodeController := NewNodeController(nil, fakeNodeHandler, 5*time.Minute, util.NewFakeRateLimiter(), util.NewFakeRateLimiter(), nodeController := NewNodeController(nil, fakeNodeHandler, 5*time.Minute, util.NewFakeRateLimiter(), util.NewFakeRateLimiter(),
@@ -884,7 +897,7 @@ func TestNodeDeletion(t *testing.T) {
if err := nodeController.monitorNodeStatus(); err != nil { if err := nodeController.monitorNodeStatus(); err != nil {
t.Errorf("unexpected error: %v", err) t.Errorf("unexpected error: %v", err)
} }
fakeNodeHandler.Delete("node1") fakeNodeHandler.Delete("node1", nil)
if err := nodeController.monitorNodeStatus(); err != nil { if err := nodeController.monitorNodeStatus(); err != nil {
t.Errorf("unexpected error: %v", err) t.Errorf("unexpected error: %v", err)
} }

9
pkg/controller/podautoscaler/horizontal.go
View File

@@ -26,7 +26,8 @@ import (
"k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/apis/extensions" "k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/client/record" "k8s.io/kubernetes/pkg/client/record"
client "k8s.io/kubernetes/pkg/client/unversioned" unversioned_extensions "k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned"
unversioned_legacy "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
"k8s.io/kubernetes/pkg/controller/podautoscaler/metrics" "k8s.io/kubernetes/pkg/controller/podautoscaler/metrics"
"k8s.io/kubernetes/pkg/util" "k8s.io/kubernetes/pkg/util"
) )
@@ -38,8 +39,8 @@ const (
) )
type HorizontalController struct { type HorizontalController struct {
scaleNamespacer client.ScaleNamespacer scaleNamespacer unversioned_extensions.ScalesGetter
hpaNamespacer client.HorizontalPodAutoscalersNamespacer hpaNamespacer unversioned_extensions.HorizontalPodAutoscalersGetter
metricsClient metrics.MetricsClient metricsClient metrics.MetricsClient
eventRecorder record.EventRecorder eventRecorder record.EventRecorder
@@ -48,7 +49,7 @@ type HorizontalController struct {
var downscaleForbiddenWindow = 5 * time.Minute var downscaleForbiddenWindow = 5 * time.Minute
var upscaleForbiddenWindow = 3 * time.Minute var upscaleForbiddenWindow = 3 * time.Minute
func NewHorizontalController(evtNamespacer client.EventNamespacer, scaleNamespacer client.ScaleNamespacer, hpaNamespacer client.HorizontalPodAutoscalersNamespacer, metricsClient metrics.MetricsClient) *HorizontalController { func NewHorizontalController(evtNamespacer unversioned_legacy.EventsGetter, scaleNamespacer unversioned_extensions.ScalesGetter, hpaNamespacer unversioned_extensions.HorizontalPodAutoscalersGetter, metricsClient metrics.MetricsClient) *HorizontalController {
broadcaster := record.NewBroadcaster() broadcaster := record.NewBroadcaster()
broadcaster.StartRecordingToSink(evtNamespacer.Events("")) broadcaster.StartRecordingToSink(evtNamespacer.Events(""))
recorder := broadcaster.NewRecorder(api.EventSource{Component: "horizontal-pod-autoscaler"}) recorder := broadcaster.NewRecorder(api.EventSource{Component: "horizontal-pod-autoscaler"})

22
pkg/controller/podautoscaler/horizontal_test.go
View File

@@ -27,6 +27,8 @@ import (
"k8s.io/kubernetes/pkg/api/resource" "k8s.io/kubernetes/pkg/api/resource"
_ "k8s.io/kubernetes/pkg/apimachinery/registered" _ "k8s.io/kubernetes/pkg/apimachinery/registered"
"k8s.io/kubernetes/pkg/apis/extensions" "k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/client/testing/core"
"k8s.io/kubernetes/pkg/client/testing/fake"
client "k8s.io/kubernetes/pkg/client/unversioned" client "k8s.io/kubernetes/pkg/client/unversioned"
"k8s.io/kubernetes/pkg/client/unversioned/testclient" "k8s.io/kubernetes/pkg/client/unversioned/testclient"
"k8s.io/kubernetes/pkg/controller/podautoscaler/metrics" "k8s.io/kubernetes/pkg/controller/podautoscaler/metrics"
@@ -67,7 +69,7 @@ type testCase struct {
verifyEvents bool verifyEvents bool
} }
func (tc *testCase) prepareTestClient(t *testing.T) *testclient.Fake { func (tc *testCase) prepareTestClient(t *testing.T) *fake.Clientset {
namespace := "test-namespace" namespace := "test-namespace"
hpaName := "test-hpa" hpaName := "test-hpa"
rcName := "test-rc" rcName := "test-rc"
@@ -76,8 +78,8 @@ func (tc *testCase) prepareTestClient(t *testing.T) *testclient.Fake {
tc.scaleUpdated = false tc.scaleUpdated = false
tc.eventCreated = false tc.eventCreated = false
fakeClient := &testclient.Fake{} fakeClient := &fake.Clientset{}
fakeClient.AddReactor("list", "horizontalpodautoscalers", func(action testclient.Action) (handled bool, ret runtime.Object, err error) { fakeClient.AddReactor("list", "horizontalpodautoscalers", func(action core.Action) (handled bool, ret runtime.Object, err error) {
obj := &extensions.HorizontalPodAutoscalerList{ obj := &extensions.HorizontalPodAutoscalerList{
Items: []extensions.HorizontalPodAutoscaler{ Items: []extensions.HorizontalPodAutoscaler{
{ {
@@ -104,7 +106,7 @@ func (tc *testCase) prepareTestClient(t *testing.T) *testclient.Fake {
return true, obj, nil return true, obj, nil
}) })
fakeClient.AddReactor("get", "replicationController", func(action testclient.Action) (handled bool, ret runtime.Object, err error) { fakeClient.AddReactor("get", "replicationController", func(action core.Action) (handled bool, ret runtime.Object, err error) {
obj := &extensions.Scale{ obj := &extensions.Scale{
ObjectMeta: api.ObjectMeta{ ObjectMeta: api.ObjectMeta{
Name: rcName, Name: rcName,
@@ -121,7 +123,7 @@ func (tc *testCase) prepareTestClient(t *testing.T) *testclient.Fake {
return true, obj, nil return true, obj, nil
}) })
fakeClient.AddReactor("list", "pods", func(action testclient.Action) (handled bool, ret runtime.Object, err error) { fakeClient.AddReactor("list", "pods", func(action core.Action) (handled bool, ret runtime.Object, err error) {
obj := &api.PodList{} obj := &api.PodList{}
for i := 0; i < len(tc.reportedCPURequests); i++ { for i := 0; i < len(tc.reportedCPURequests); i++ {
podName := fmt.Sprintf("%s-%d", podNamePrefix, i) podName := fmt.Sprintf("%s-%d", podNamePrefix, i)
@@ -153,7 +155,7 @@ func (tc *testCase) prepareTestClient(t *testing.T) *testclient.Fake {
return true, obj, nil return true, obj, nil
}) })
fakeClient.AddProxyReactor("services", func(action testclient.Action) (handled bool, ret client.ResponseWrapper, err error) { fakeClient.AddProxyReactor("services", func(action core.Action) (handled bool, ret client.ResponseWrapper, err error) {
timestamp := time.Now() timestamp := time.Now()
metrics := heapster.MetricResultList{} metrics := heapster.MetricResultList{}
for _, level := range tc.reportedLevels { for _, level := range tc.reportedLevels {
@@ -167,7 +169,7 @@ func (tc *testCase) prepareTestClient(t *testing.T) *testclient.Fake {
return true, newFakeResponseWrapper(heapsterRawMemResponse), nil return true, newFakeResponseWrapper(heapsterRawMemResponse), nil
}) })
fakeClient.AddReactor("update", "replicationController", func(action testclient.Action) (handled bool, ret runtime.Object, err error) { fakeClient.AddReactor("update", "replicationController", func(action core.Action) (handled bool, ret runtime.Object, err error) {
obj := action.(testclient.UpdateAction).GetObject().(*extensions.Scale) obj := action.(testclient.UpdateAction).GetObject().(*extensions.Scale)
replicas := action.(testclient.UpdateAction).GetObject().(*extensions.Scale).Spec.Replicas replicas := action.(testclient.UpdateAction).GetObject().(*extensions.Scale).Spec.Replicas
assert.Equal(t, tc.desiredReplicas, replicas) assert.Equal(t, tc.desiredReplicas, replicas)
@@ -175,7 +177,7 @@ func (tc *testCase) prepareTestClient(t *testing.T) *testclient.Fake {
return true, obj, nil return true, obj, nil
}) })
fakeClient.AddReactor("update", "horizontalpodautoscalers", func(action testclient.Action) (handled bool, ret runtime.Object, err error) { fakeClient.AddReactor("update", "horizontalpodautoscalers", func(action core.Action) (handled bool, ret runtime.Object, err error) {
obj := action.(testclient.UpdateAction).GetObject().(*extensions.HorizontalPodAutoscaler) obj := action.(testclient.UpdateAction).GetObject().(*extensions.HorizontalPodAutoscaler)
assert.Equal(t, namespace, obj.Namespace) assert.Equal(t, namespace, obj.Namespace)
assert.Equal(t, hpaName, obj.Name) assert.Equal(t, hpaName, obj.Name)
@@ -183,7 +185,7 @@ func (tc *testCase) prepareTestClient(t *testing.T) *testclient.Fake {
return true, obj, nil return true, obj, nil
}) })
fakeClient.AddReactor("*", "events", func(action testclient.Action) (handled bool, ret runtime.Object, err error) { fakeClient.AddReactor("*", "events", func(action core.Action) (handled bool, ret runtime.Object, err error) {
obj := action.(testclient.CreateAction).GetObject().(*api.Event) obj := action.(testclient.CreateAction).GetObject().(*api.Event)
if tc.verifyEvents { if tc.verifyEvents {
assert.Equal(t, "SuccessfulRescale", obj.Reason) assert.Equal(t, "SuccessfulRescale", obj.Reason)
@@ -206,7 +208,7 @@ func (tc *testCase) verifyResults(t *testing.T) {
func (tc *testCase) runTest(t *testing.T) { func (tc *testCase) runTest(t *testing.T) {
testClient := tc.prepareTestClient(t) testClient := tc.prepareTestClient(t)
metricsClient := metrics.NewHeapsterMetricsClient(testClient, metrics.DefaultHeapsterNamespace, metrics.DefaultHeapsterScheme, metrics.DefaultHeapsterService, metrics.DefaultHeapsterPort) metricsClient := metrics.NewHeapsterMetricsClient(testClient, metrics.DefaultHeapsterNamespace, metrics.DefaultHeapsterScheme, metrics.DefaultHeapsterService, metrics.DefaultHeapsterPort)
hpaController := NewHorizontalController(testClient, testClient.Extensions(), testClient.Extensions(), metricsClient) hpaController := NewHorizontalController(testClient.Legacy(), testClient.Extensions(), testClient.Extensions(), metricsClient)
err := hpaController.reconcileAutoscalers() err := hpaController.reconcileAutoscalers()
assert.Equal(t, nil, err) assert.Equal(t, nil, err)
if tc.verifyEvents { if tc.verifyEvents {

12
pkg/controller/podautoscaler/metrics/metrics_client.go
View File

@@ -24,7 +24,7 @@ import (
"github.com/golang/glog" "github.com/golang/glog"
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
client "k8s.io/kubernetes/pkg/client/unversioned" clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
"k8s.io/kubernetes/pkg/labels" "k8s.io/kubernetes/pkg/labels"
heapster "k8s.io/heapster/api/v1/types" heapster "k8s.io/heapster/api/v1/types"
@@ -66,7 +66,7 @@ type metricDefinition struct {
// HeapsterMetricsClient is Heapster-based implementation of MetricsClient // HeapsterMetricsClient is Heapster-based implementation of MetricsClient
type HeapsterMetricsClient struct { type HeapsterMetricsClient struct {
client client.Interface client clientset.Interface
heapsterNamespace string heapsterNamespace string
heapsterScheme string heapsterScheme string
heapsterService string heapsterService string
@@ -90,7 +90,7 @@ func getHeapsterCustomMetricDefinition(metricName string) metricDefinition {
} }
// NewHeapsterMetricsClient returns a new instance of Heapster-based implementation of MetricsClient interface. // NewHeapsterMetricsClient returns a new instance of Heapster-based implementation of MetricsClient interface.
func NewHeapsterMetricsClient(client client.Interface, namespace, scheme, service, port string) *HeapsterMetricsClient { func NewHeapsterMetricsClient(client clientset.Interface, namespace, scheme, service, port string) *HeapsterMetricsClient {
return &HeapsterMetricsClient{ return &HeapsterMetricsClient{
client: client, client: client,
heapsterNamespace: namespace, heapsterNamespace: namespace,
@@ -113,7 +113,7 @@ func (h *HeapsterMetricsClient) GetCpuConsumptionAndRequestInMillis(namespace st
avgRequest int64, timestamp time.Time, err error) { avgRequest int64, timestamp time.Time, err error) {
labelSelector := labels.SelectorFromSet(labels.Set(selector)) labelSelector := labels.SelectorFromSet(labels.Set(selector))
podList, err := h.client.Pods(namespace). podList, err := h.client.Legacy().Pods(namespace).
List(api.ListOptions{LabelSelector: labelSelector}) List(api.ListOptions{LabelSelector: labelSelector})
if err != nil { if err != nil {
@@ -152,7 +152,7 @@ func (h *HeapsterMetricsClient) GetCustomMetric(customMetricName string, namespa
metricSpec := getHeapsterCustomMetricDefinition(customMetricName) metricSpec := getHeapsterCustomMetricDefinition(customMetricName)
labelSelector := labels.SelectorFromSet(labels.Set(selector)) labelSelector := labels.SelectorFromSet(labels.Set(selector))
podList, err := h.client.Pods(namespace).List(api.ListOptions{LabelSelector: labelSelector}) podList, err := h.client.Legacy().Pods(namespace).List(api.ListOptions{LabelSelector: labelSelector})
if err != nil { if err != nil {
return nil, time.Time{}, fmt.Errorf("failed to get pod list: %v", err) return nil, time.Time{}, fmt.Errorf("failed to get pod list: %v", err)
@@ -179,7 +179,7 @@ func (h *HeapsterMetricsClient) getForPods(metricSpec metricDefinition, namespac
strings.Join(podNames, ","), strings.Join(podNames, ","),
metricSpec.name) metricSpec.name)
resultRaw, err := h.client.Services(h.heapsterNamespace). resultRaw, err := h.client.Legacy().Services(h.heapsterNamespace).
ProxyGet(h.heapsterScheme, h.heapsterService, h.heapsterPort, metricPath, map[string]string{"start": startTime.Format(time.RFC3339)}). ProxyGet(h.heapsterScheme, h.heapsterService, h.heapsterPort, metricPath, map[string]string{"start": startTime.Format(time.RFC3339)}).
DoRaw() DoRaw()

11
pkg/controller/podautoscaler/metrics/metrics_client_test.go
View File

@@ -26,8 +26,9 @@ import (
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/resource" "k8s.io/kubernetes/pkg/api/resource"
_ "k8s.io/kubernetes/pkg/apimachinery/registered" _ "k8s.io/kubernetes/pkg/apimachinery/registered"
"k8s.io/kubernetes/pkg/client/testing/core"
"k8s.io/kubernetes/pkg/client/testing/fake"
client "k8s.io/kubernetes/pkg/client/unversioned" client "k8s.io/kubernetes/pkg/client/unversioned"
"k8s.io/kubernetes/pkg/client/unversioned/testclient"
"k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/runtime"
heapster "k8s.io/heapster/api/v1/types" heapster "k8s.io/heapster/api/v1/types"
@@ -70,16 +71,16 @@ type testCase struct {
selector map[string]string selector map[string]string
} }
func (tc *testCase) prepareTestClient(t *testing.T) *testclient.Fake { func (tc *testCase) prepareTestClient(t *testing.T) *fake.Clientset {
namespace := "test-namespace" namespace := "test-namespace"
tc.namespace = namespace tc.namespace = namespace
podNamePrefix := "test-pod" podNamePrefix := "test-pod"
selector := map[string]string{"name": podNamePrefix} selector := map[string]string{"name": podNamePrefix}
tc.selector = selector tc.selector = selector
fakeClient := &testclient.Fake{} fakeClient := &fake.Clientset{}
fakeClient.AddReactor("list", "pods", func(action testclient.Action) (handled bool, ret runtime.Object, err error) { fakeClient.AddReactor("list", "pods", func(action core.Action) (handled bool, ret runtime.Object, err error) {
obj := &api.PodList{} obj := &api.PodList{}
for i := 0; i < tc.replicas; i++ { for i := 0; i < tc.replicas; i++ {
podName := fmt.Sprintf("%s-%d", podNamePrefix, i) podName := fmt.Sprintf("%s-%d", podNamePrefix, i)
@@ -109,7 +110,7 @@ func (tc *testCase) prepareTestClient(t *testing.T) *testclient.Fake {
return true, obj, nil return true, obj, nil
}) })
fakeClient.AddProxyReactor("services", func(action testclient.Action) (handled bool, ret client.ResponseWrapper, err error) { fakeClient.AddProxyReactor("services", func(action core.Action) (handled bool, ret client.ResponseWrapper, err error) {
metrics := heapster.MetricResultList{} metrics := heapster.MetricResultList{}
var latestTimestamp time.Time var latestTimestamp time.Time
for _, reportedMetricPoints := range tc.reportedMetricsPoints { for _, reportedMetricPoints := range tc.reportedMetricsPoints {

28
pkg/controller/resourcequota/resource_quota_controller.go
View File

@@ -24,7 +24,7 @@ import (
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/resource" "k8s.io/kubernetes/pkg/api/resource"
"k8s.io/kubernetes/pkg/client/cache" "k8s.io/kubernetes/pkg/client/cache"
client "k8s.io/kubernetes/pkg/client/unversioned" clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
"k8s.io/kubernetes/pkg/controller" "k8s.io/kubernetes/pkg/controller"
"k8s.io/kubernetes/pkg/controller/framework" "k8s.io/kubernetes/pkg/controller/framework"
"k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/runtime"
@@ -37,7 +37,7 @@ import (
// ResourceQuotaController is responsible for tracking quota usage status in the system // ResourceQuotaController is responsible for tracking quota usage status in the system
type ResourceQuotaController struct { type ResourceQuotaController struct {
// Must have authority to list all resources in the system, and update quota status // Must have authority to list all resources in the system, and update quota status
kubeClient client.Interface kubeClient clientset.Interface
// An index of resource quota objects by namespace // An index of resource quota objects by namespace
rqIndexer cache.Indexer rqIndexer cache.Indexer
// Watches changes to all resource quota // Watches changes to all resource quota
@@ -55,7 +55,7 @@ type ResourceQuotaController struct {
} }
// NewResourceQuotaController creates a new ResourceQuotaController // NewResourceQuotaController creates a new ResourceQuotaController
func NewResourceQuotaController(kubeClient client.Interface, resyncPeriod controller.ResyncPeriodFunc) *ResourceQuotaController { func NewResourceQuotaController(kubeClient clientset.Interface, resyncPeriod controller.ResyncPeriodFunc) *ResourceQuotaController {
rq := &ResourceQuotaController{ rq := &ResourceQuotaController{
kubeClient: kubeClient, kubeClient: kubeClient,
@@ -66,10 +66,10 @@ func NewResourceQuotaController(kubeClient client.Interface, resyncPeriod contro
rq.rqIndexer, rq.rqController = framework.NewIndexerInformer( rq.rqIndexer, rq.rqController = framework.NewIndexerInformer(
&cache.ListWatch{ &cache.ListWatch{
ListFunc: func(options api.ListOptions) (runtime.Object, error) { ListFunc: func(options api.ListOptions) (runtime.Object, error) {
return rq.kubeClient.ResourceQuotas(api.NamespaceAll).List(options) return rq.kubeClient.Legacy().ResourceQuotas(api.NamespaceAll).List(options)
}, },
WatchFunc: func(options api.ListOptions) (watch.Interface, error) { WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
return rq.kubeClient.ResourceQuotas(api.NamespaceAll).Watch(options) return rq.kubeClient.Legacy().ResourceQuotas(api.NamespaceAll).Watch(options)
}, },
}, },
&api.ResourceQuota{}, &api.ResourceQuota{},
@@ -106,10 +106,10 @@ func NewResourceQuotaController(kubeClient client.Interface, resyncPeriod contro
rq.podStore.Store, rq.podController = framework.NewInformer( rq.podStore.Store, rq.podController = framework.NewInformer(
&cache.ListWatch{ &cache.ListWatch{
ListFunc: func(options api.ListOptions) (runtime.Object, error) { ListFunc: func(options api.ListOptions) (runtime.Object, error) {
return rq.kubeClient.Pods(api.NamespaceAll).List(options) return rq.kubeClient.Legacy().Pods(api.NamespaceAll).List(options)
}, },
WatchFunc: func(options api.ListOptions) (watch.Interface, error) { WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
return rq.kubeClient.Pods(api.NamespaceAll).Watch(options) return rq.kubeClient.Legacy().Pods(api.NamespaceAll).Watch(options)
}, },
}, },
&api.Pod{}, &api.Pod{},
@@ -265,7 +265,7 @@ func (rq *ResourceQuotaController) syncResourceQuota(quota api.ResourceQuota) (e
pods := &api.PodList{} pods := &api.PodList{}
if set[api.ResourcePods] || set[api.ResourceMemory] || set[api.ResourceCPU] { if set[api.ResourcePods] || set[api.ResourceMemory] || set[api.ResourceCPU] {
pods, err = rq.kubeClient.Pods(usage.Namespace).List(api.ListOptions{}) pods, err = rq.kubeClient.Legacy().Pods(usage.Namespace).List(api.ListOptions{})
if err != nil { if err != nil {
return err return err
} }
@@ -288,31 +288,31 @@ func (rq *ResourceQuotaController) syncResourceQuota(quota api.ResourceQuota) (e
case api.ResourcePods: case api.ResourcePods:
value = resource.NewQuantity(int64(len(filteredPods)), resource.DecimalSI) value = resource.NewQuantity(int64(len(filteredPods)), resource.DecimalSI)
case api.ResourceServices: case api.ResourceServices:
items, err := rq.kubeClient.Services(usage.Namespace).List(api.ListOptions{}) items, err := rq.kubeClient.Legacy().Services(usage.Namespace).List(api.ListOptions{})
if err != nil { if err != nil {
return err return err
} }
value = resource.NewQuantity(int64(len(items.Items)), resource.DecimalSI) value = resource.NewQuantity(int64(len(items.Items)), resource.DecimalSI)
case api.ResourceReplicationControllers: case api.ResourceReplicationControllers:
items, err := rq.kubeClient.ReplicationControllers(usage.Namespace).List(api.ListOptions{}) items, err := rq.kubeClient.Legacy().ReplicationControllers(usage.Namespace).List(api.ListOptions{})
if err != nil { if err != nil {
return err return err
} }
value = resource.NewQuantity(int64(len(items.Items)), resource.DecimalSI) value = resource.NewQuantity(int64(len(items.Items)), resource.DecimalSI)
case api.ResourceQuotas: case api.ResourceQuotas:
items, err := rq.kubeClient.ResourceQuotas(usage.Namespace).List(api.ListOptions{}) items, err := rq.kubeClient.Legacy().ResourceQuotas(usage.Namespace).List(api.ListOptions{})
if err != nil { if err != nil {
return err return err
} }
value = resource.NewQuantity(int64(len(items.Items)), resource.DecimalSI) value = resource.NewQuantity(int64(len(items.Items)), resource.DecimalSI)
case api.ResourceSecrets: case api.ResourceSecrets:
items, err := rq.kubeClient.Secrets(usage.Namespace).List(api.ListOptions{}) items, err := rq.kubeClient.Legacy().Secrets(usage.Namespace).List(api.ListOptions{})
if err != nil { if err != nil {
return err return err
} }
value = resource.NewQuantity(int64(len(items.Items)), resource.DecimalSI) value = resource.NewQuantity(int64(len(items.Items)), resource.DecimalSI)
case api.ResourcePersistentVolumeClaims: case api.ResourcePersistentVolumeClaims:
items, err := rq.kubeClient.PersistentVolumeClaims(usage.Namespace).List(api.ListOptions{}) items, err := rq.kubeClient.Legacy().PersistentVolumeClaims(usage.Namespace).List(api.ListOptions{})
if err != nil { if err != nil {
return err return err
} }
@@ -334,7 +334,7 @@ func (rq *ResourceQuotaController) syncResourceQuota(quota api.ResourceQuota) (e
// update the usage only if it changed // update the usage only if it changed
if dirty { if dirty {
_, err = rq.kubeClient.ResourceQuotas(usage.Namespace).UpdateStatus(&usage) _, err = rq.kubeClient.Legacy().ResourceQuotas(usage.Namespace).UpdateStatus(&usage)
return err return err
} }
return nil return nil

7
pkg/controller/resourcequota/resource_quota_controller_test.go
View File

@@ -23,6 +23,7 @@ import (
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/resource" "k8s.io/kubernetes/pkg/api/resource"
"k8s.io/kubernetes/pkg/client/testing/fake"
"k8s.io/kubernetes/pkg/client/unversioned/testclient" "k8s.io/kubernetes/pkg/client/unversioned/testclient"
"k8s.io/kubernetes/pkg/controller" "k8s.io/kubernetes/pkg/controller"
"k8s.io/kubernetes/pkg/util/sets" "k8s.io/kubernetes/pkg/util/sets"
@@ -173,7 +174,7 @@ func TestSyncResourceQuota(t *testing.T) {
}, },
} }
kubeClient := testclient.NewSimpleFake(&podList, &quota) kubeClient := fake.NewSimpleClientset(&podList, &quota)
ResourceQuotaController := NewResourceQuotaController(kubeClient, controller.StaticResyncPeriodFunc(time.Second)) ResourceQuotaController := NewResourceQuotaController(kubeClient, controller.StaticResyncPeriodFunc(time.Second))
err := ResourceQuotaController.syncResourceQuota(quota) err := ResourceQuotaController.syncResourceQuota(quota)
@@ -230,7 +231,7 @@ func TestSyncResourceQuotaSpecChange(t *testing.T) {
}, },
} }
kubeClient := testclient.NewSimpleFake(&quota) kubeClient := fake.NewSimpleClientset(&quota)
ResourceQuotaController := NewResourceQuotaController(kubeClient, controller.StaticResyncPeriodFunc(time.Second)) ResourceQuotaController := NewResourceQuotaController(kubeClient, controller.StaticResyncPeriodFunc(time.Second))
err := ResourceQuotaController.syncResourceQuota(quota) err := ResourceQuotaController.syncResourceQuota(quota)
@@ -277,7 +278,7 @@ func TestSyncResourceQuotaNoChange(t *testing.T) {
}, },
} }
kubeClient := testclient.NewSimpleFake(&api.PodList{}, &quota) kubeClient := fake.NewSimpleClientset(&api.PodList{}, &quota)
ResourceQuotaController := NewResourceQuotaController(kubeClient, controller.StaticResyncPeriodFunc(time.Second)) ResourceQuotaController := NewResourceQuotaController(kubeClient, controller.StaticResyncPeriodFunc(time.Second))
err := ResourceQuotaController.syncResourceQuota(quota) err := ResourceQuotaController.syncResourceQuota(quota)

8
pkg/controller/route/routecontroller.go
View File

@@ -23,19 +23,19 @@ import (
"github.com/golang/glog" "github.com/golang/glog"
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
client "k8s.io/kubernetes/pkg/client/unversioned" clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
"k8s.io/kubernetes/pkg/cloudprovider" "k8s.io/kubernetes/pkg/cloudprovider"
"k8s.io/kubernetes/pkg/util" "k8s.io/kubernetes/pkg/util"
) )
type RouteController struct { type RouteController struct {
routes cloudprovider.Routes routes cloudprovider.Routes
kubeClient client.Interface kubeClient clientset.Interface
clusterName string clusterName string
clusterCIDR *net.IPNet clusterCIDR *net.IPNet
} }
func New(routes cloudprovider.Routes, kubeClient client.Interface, clusterName string, clusterCIDR *net.IPNet) *RouteController { func New(routes cloudprovider.Routes, kubeClient clientset.Interface, clusterName string, clusterCIDR *net.IPNet) *RouteController {
return &RouteController{ return &RouteController{
routes: routes, routes: routes,
kubeClient: kubeClient, kubeClient: kubeClient,
@@ -59,7 +59,7 @@ func (rc *RouteController) reconcileNodeRoutes() error {
} }
// TODO (cjcullen): use pkg/controller/framework.NewInformer to watch this // TODO (cjcullen): use pkg/controller/framework.NewInformer to watch this
// and reduce the number of lists needed. // and reduce the number of lists needed.
nodeList, err := rc.kubeClient.Nodes().List(api.ListOptions{}) nodeList, err := rc.kubeClient.Legacy().Nodes().List(api.ListOptions{})
if err != nil { if err != nil {
return fmt.Errorf("error listing nodes: %v", err) return fmt.Errorf("error listing nodes: %v", err)
} }

19
pkg/controller/service/servicecontroller.go
View File

@@ -27,8 +27,9 @@ import (
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/errors" "k8s.io/kubernetes/pkg/api/errors"
"k8s.io/kubernetes/pkg/client/cache" "k8s.io/kubernetes/pkg/client/cache"
clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
"k8s.io/kubernetes/pkg/client/record" "k8s.io/kubernetes/pkg/client/record"
client "k8s.io/kubernetes/pkg/client/unversioned" unversioned_legacy "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
"k8s.io/kubernetes/pkg/cloudprovider" "k8s.io/kubernetes/pkg/cloudprovider"
"k8s.io/kubernetes/pkg/fields" "k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/types" "k8s.io/kubernetes/pkg/types"
@@ -67,7 +68,7 @@ type serviceCache struct {
type ServiceController struct { type ServiceController struct {
cloud cloudprovider.Interface cloud cloudprovider.Interface
kubeClient client.Interface kubeClient clientset.Interface
clusterName string clusterName string
balancer cloudprovider.LoadBalancer balancer cloudprovider.LoadBalancer
zone cloudprovider.Zone zone cloudprovider.Zone
@@ -79,9 +80,9 @@ type ServiceController struct {
// New returns a new service controller to keep cloud provider service resources // New returns a new service controller to keep cloud provider service resources
// (like load balancers) in sync with the registry. // (like load balancers) in sync with the registry.
func New(cloud cloudprovider.Interface, kubeClient client.Interface, clusterName string) *ServiceController { func New(cloud cloudprovider.Interface, kubeClient clientset.Interface, clusterName string) *ServiceController {
broadcaster := record.NewBroadcaster() broadcaster := record.NewBroadcaster()
broadcaster.StartRecordingToSink(kubeClient.Events("")) broadcaster.StartRecordingToSink(&unversioned_legacy.EventSinkImpl{kubeClient.Legacy().Events("")})
recorder := broadcaster.NewRecorder(api.EventSource{Component: "service-controller"}) recorder := broadcaster.NewRecorder(api.EventSource{Component: "service-controller"})
return &ServiceController{ return &ServiceController{
@@ -115,8 +116,8 @@ func (s *ServiceController) Run(serviceSyncPeriod, nodeSyncPeriod time.Duration)
// We have to make this check beecause the ListWatch that we use in // We have to make this check beecause the ListWatch that we use in
// WatchServices requires Client functions that aren't in the interface // WatchServices requires Client functions that aren't in the interface
// for some reason. // for some reason.
if _, ok := s.kubeClient.(*client.Client); !ok { if _, ok := s.kubeClient.(*clientset.Clientset); !ok {
return fmt.Errorf("ServiceController only works with real Client objects, but was passed something else satisfying the client Interface.") return fmt.Errorf("ServiceController only works with real Client objects, but was passed something else satisfying the clientset.Interface.")
} }
// Get the currently existing set of services and then all future creates // Get the currently existing set of services and then all future creates
@@ -133,13 +134,13 @@ func (s *ServiceController) Run(serviceSyncPeriod, nodeSyncPeriod time.Duration)
}), }),
s.cache, s.cache,
) )
lw := cache.NewListWatchFromClient(s.kubeClient.(*client.Client), "services", api.NamespaceAll, fields.Everything()) lw := cache.NewListWatchFromClient(s.kubeClient.(*clientset.Clientset).LegacyClient, "services", api.NamespaceAll, fields.Everything())
cache.NewReflector(lw, &api.Service{}, serviceQueue, serviceSyncPeriod).Run() cache.NewReflector(lw, &api.Service{}, serviceQueue, serviceSyncPeriod).Run()
for i := 0; i < workerGoroutines; i++ { for i := 0; i < workerGoroutines; i++ {
go s.watchServices(serviceQueue) go s.watchServices(serviceQueue)
} }
nodeLW := cache.NewListWatchFromClient(s.kubeClient.(*client.Client), "nodes", api.NamespaceAll, fields.Everything()) nodeLW := cache.NewListWatchFromClient(s.kubeClient.(*clientset.Clientset).LegacyClient, "nodes", api.NamespaceAll, fields.Everything())
cache.NewReflector(nodeLW, &api.Node{}, s.nodeLister.Store, 0).Run() cache.NewReflector(nodeLW, &api.Node{}, s.nodeLister.Store, 0).Run()
go s.nodeSyncLoop(nodeSyncPeriod) go s.nodeSyncLoop(nodeSyncPeriod)
return nil return nil
@@ -343,7 +344,7 @@ func (s *ServiceController) createLoadBalancerIfNeeded(namespacedName types.Name
func (s *ServiceController) persistUpdate(service *api.Service) error { func (s *ServiceController) persistUpdate(service *api.Service) error {
var err error var err error
for i := 0; i < clientRetryCount; i++ { for i := 0; i < clientRetryCount; i++ {
_, err = s.kubeClient.Services(service.Namespace).UpdateStatus(service) _, err = s.kubeClient.Legacy().Services(service.Namespace).UpdateStatus(service)
if err == nil { if err == nil {
return nil return nil
} }

6
pkg/controller/service/servicecontroller_test.go
View File

@@ -21,7 +21,7 @@ import (
"testing" "testing"
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/client/unversioned/testclient" "k8s.io/kubernetes/pkg/client/testing/fake"
fakecloud "k8s.io/kubernetes/pkg/cloudprovider/providers/fake" fakecloud "k8s.io/kubernetes/pkg/cloudprovider/providers/fake"
"k8s.io/kubernetes/pkg/types" "k8s.io/kubernetes/pkg/types"
) )
@@ -90,7 +90,7 @@ func TestCreateExternalLoadBalancer(t *testing.T) {
for _, item := range table { for _, item := range table {
cloud := &fakecloud.FakeCloud{} cloud := &fakecloud.FakeCloud{}
cloud.Region = region cloud.Region = region
client := &testclient.Fake{} client := &fake.Clientset{}
controller := New(cloud, client, "test-cluster") controller := New(cloud, client, "test-cluster")
controller.init() controller.init()
cloud.Calls = nil // ignore any cloud calls made in init() cloud.Calls = nil // ignore any cloud calls made in init()
@@ -210,7 +210,7 @@ func TestUpdateNodesInExternalLoadBalancer(t *testing.T) {
cloud := &fakecloud.FakeCloud{} cloud := &fakecloud.FakeCloud{}
cloud.Region = region cloud.Region = region
client := &testclient.Fake{} client := &fake.Clientset{}
controller := New(cloud, client, "test-cluster2") controller := New(cloud, client, "test-cluster2")
controller.init() controller.init()
cloud.Calls = nil // ignore any cloud calls made in init() cloud.Calls = nil // ignore any cloud calls made in init()

15
pkg/controller/serviceaccount/serviceaccounts_controller.go
View File

@@ -25,6 +25,7 @@ import (
apierrs "k8s.io/kubernetes/pkg/api/errors" apierrs "k8s.io/kubernetes/pkg/api/errors"
"k8s.io/kubernetes/pkg/api/meta" "k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/client/cache" "k8s.io/kubernetes/pkg/client/cache"
clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
client "k8s.io/kubernetes/pkg/client/unversioned" client "k8s.io/kubernetes/pkg/client/unversioned"
"k8s.io/kubernetes/pkg/controller/framework" "k8s.io/kubernetes/pkg/controller/framework"
"k8s.io/kubernetes/pkg/fields" "k8s.io/kubernetes/pkg/fields"
@@ -66,7 +67,7 @@ func DefaultServiceAccountsControllerOptions() ServiceAccountsControllerOptions
} }
// NewServiceAccountsController returns a new *ServiceAccountsController. // NewServiceAccountsController returns a new *ServiceAccountsController.
func NewServiceAccountsController(cl client.Interface, options ServiceAccountsControllerOptions) *ServiceAccountsController { func NewServiceAccountsController(cl clientset.Interface, options ServiceAccountsControllerOptions) *ServiceAccountsController {
e := &ServiceAccountsController{ e := &ServiceAccountsController{
client: cl, client: cl,
serviceAccountsToEnsure: options.ServiceAccounts, serviceAccountsToEnsure: options.ServiceAccounts,
@@ -81,11 +82,11 @@ func NewServiceAccountsController(cl client.Interface, options ServiceAccountsCo
&cache.ListWatch{ &cache.ListWatch{
ListFunc: func(options api.ListOptions) (runtime.Object, error) { ListFunc: func(options api.ListOptions) (runtime.Object, error) {
options.FieldSelector = accountSelector options.FieldSelector = accountSelector
return e.client.ServiceAccounts(api.NamespaceAll).List(options) return e.client.Legacy().ServiceAccounts(api.NamespaceAll).List(options)
}, },
WatchFunc: func(options api.ListOptions) (watch.Interface, error) { WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
options.FieldSelector = accountSelector options.FieldSelector = accountSelector
return e.client.ServiceAccounts(api.NamespaceAll).Watch(options) return e.client.Legacy().ServiceAccounts(api.NamespaceAll).Watch(options)
}, },
}, },
&api.ServiceAccount{}, &api.ServiceAccount{},
@@ -99,10 +100,10 @@ func NewServiceAccountsController(cl client.Interface, options ServiceAccountsCo
e.namespaces, e.namespaceController = framework.NewIndexerInformer( e.namespaces, e.namespaceController = framework.NewIndexerInformer(
&cache.ListWatch{ &cache.ListWatch{
ListFunc: func(options api.ListOptions) (runtime.Object, error) { ListFunc: func(options api.ListOptions) (runtime.Object, error) {
return e.client.Namespaces().List(options) return e.client.Legacy().Namespaces().List(options)
}, },
WatchFunc: func(options api.ListOptions) (watch.Interface, error) { WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
return e.client.Namespaces().Watch(options) return e.client.Legacy().Namespaces().Watch(options)
}, },
}, },
&api.Namespace{}, &api.Namespace{},
@@ -121,7 +122,7 @@ func NewServiceAccountsController(cl client.Interface, options ServiceAccountsCo
type ServiceAccountsController struct { type ServiceAccountsController struct {
stopChan chan struct{} stopChan chan struct{}
client client.Interface client clientset.Interface
serviceAccountsToEnsure []api.ServiceAccount serviceAccountsToEnsure []api.ServiceAccount
serviceAccounts cache.Indexer serviceAccounts cache.Indexer
@@ -216,7 +217,7 @@ func (e *ServiceAccountsController) createServiceAccountIfNeeded(sa api.ServiceA
// createDefaultServiceAccount creates a default ServiceAccount in the specified namespace // createDefaultServiceAccount creates a default ServiceAccount in the specified namespace
func (e *ServiceAccountsController) createServiceAccount(sa api.ServiceAccount, namespace string) { func (e *ServiceAccountsController) createServiceAccount(sa api.ServiceAccount, namespace string) {
sa.Namespace = namespace sa.Namespace = namespace
if _, err := e.client.ServiceAccounts(namespace).Create(&sa); err != nil && !apierrs.IsAlreadyExists(err) { if _, err := e.client.Legacy().ServiceAccounts(namespace).Create(&sa); err != nil && !apierrs.IsAlreadyExists(err) {
glog.Error(err) glog.Error(err)
} }
} }

3
pkg/controller/serviceaccount/serviceaccounts_controller_test.go
View File

@@ -20,6 +20,7 @@ import (
"testing" "testing"
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/client/testing/fake"
"k8s.io/kubernetes/pkg/client/unversioned/testclient" "k8s.io/kubernetes/pkg/client/unversioned/testclient"
"k8s.io/kubernetes/pkg/util/sets" "k8s.io/kubernetes/pkg/util/sets"
) )
@@ -149,7 +150,7 @@ func TestServiceAccountCreation(t *testing.T) {
} }
for k, tc := range testcases { for k, tc := range testcases {
client := testclient.NewSimpleFake(defaultServiceAccount, managedServiceAccount) client := fake.NewSimpleClientset(defaultServiceAccount, managedServiceAccount)
options := DefaultServiceAccountsControllerOptions() options := DefaultServiceAccountsControllerOptions()
options.ServiceAccounts = []api.ServiceAccount{ options.ServiceAccounts = []api.ServiceAccount{
{ObjectMeta: api.ObjectMeta{Name: defaultName}}, {ObjectMeta: api.ObjectMeta{Name: defaultName}},

12
pkg/controller/serviceaccount/tokengetter.go
View File

@@ -18,7 +18,7 @@ package serviceaccount
import ( import (
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
client "k8s.io/kubernetes/pkg/client/unversioned" clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
"k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/secret" "k8s.io/kubernetes/pkg/registry/secret"
secretetcd "k8s.io/kubernetes/pkg/registry/secret/etcd" secretetcd "k8s.io/kubernetes/pkg/registry/secret/etcd"
@@ -28,23 +28,23 @@ import (
"k8s.io/kubernetes/pkg/storage" "k8s.io/kubernetes/pkg/storage"
) )
// clientGetter implements ServiceAccountTokenGetter using a client.Interface // clientGetter implements ServiceAccountTokenGetter using a clientset.Interface
type clientGetter struct { type clientGetter struct {
client client.Interface client clientset.Interface
} }
// NewGetterFromClient returns a ServiceAccountTokenGetter that // NewGetterFromClient returns a ServiceAccountTokenGetter that
// uses the specified client to retrieve service accounts and secrets. // uses the specified client to retrieve service accounts and secrets.
// The client should NOT authenticate using a service account token // The client should NOT authenticate using a service account token
// the returned getter will be used to retrieve, or recursion will result. // the returned getter will be used to retrieve, or recursion will result.
func NewGetterFromClient(c client.Interface) serviceaccount.ServiceAccountTokenGetter { func NewGetterFromClient(c clientset.Interface) serviceaccount.ServiceAccountTokenGetter {
return clientGetter{c} return clientGetter{c}
} }
func (c clientGetter) GetServiceAccount(namespace, name string) (*api.ServiceAccount, error) { func (c clientGetter) GetServiceAccount(namespace, name string) (*api.ServiceAccount, error) {
return c.client.ServiceAccounts(namespace).Get(name) return c.client.Legacy().ServiceAccounts(namespace).Get(name)
} }
func (c clientGetter) GetSecret(namespace, name string) (*api.Secret, error) { func (c clientGetter) GetSecret(namespace, name string) (*api.Secret, error) {
return c.client.Secrets(namespace).Get(name) return c.client.Legacy().Secrets(namespace).Get(name)
} }
// registryGetter implements ServiceAccountTokenGetter using a service account and secret registry // registryGetter implements ServiceAccountTokenGetter using a service account and secret registry

27
pkg/controller/serviceaccount/tokens_controller.go
View File

@@ -25,6 +25,7 @@ import (
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
apierrors "k8s.io/kubernetes/pkg/api/errors" apierrors "k8s.io/kubernetes/pkg/api/errors"
"k8s.io/kubernetes/pkg/client/cache" "k8s.io/kubernetes/pkg/client/cache"
clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
client "k8s.io/kubernetes/pkg/client/unversioned" client "k8s.io/kubernetes/pkg/client/unversioned"
"k8s.io/kubernetes/pkg/controller/framework" "k8s.io/kubernetes/pkg/controller/framework"
"k8s.io/kubernetes/pkg/fields" "k8s.io/kubernetes/pkg/fields"
@@ -61,7 +62,7 @@ type TokensControllerOptions struct {
} }
// NewTokensController returns a new *TokensController. // NewTokensController returns a new *TokensController.
func NewTokensController(cl client.Interface, options TokensControllerOptions) *TokensController { func NewTokensController(cl clientset.Interface, options TokensControllerOptions) *TokensController {
e := &TokensController{ e := &TokensController{
client: cl, client: cl,
token: options.TokenGenerator, token: options.TokenGenerator,
@@ -71,10 +72,10 @@ func NewTokensController(cl client.Interface, options TokensControllerOptions) *
e.serviceAccounts, e.serviceAccountController = framework.NewIndexerInformer( e.serviceAccounts, e.serviceAccountController = framework.NewIndexerInformer(
&cache.ListWatch{ &cache.ListWatch{
ListFunc: func(options api.ListOptions) (runtime.Object, error) { ListFunc: func(options api.ListOptions) (runtime.Object, error) {
return e.client.ServiceAccounts(api.NamespaceAll).List(options) return e.client.Legacy().ServiceAccounts(api.NamespaceAll).List(options)
}, },
WatchFunc: func(options api.ListOptions) (watch.Interface, error) { WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
return e.client.ServiceAccounts(api.NamespaceAll).Watch(options) return e.client.Legacy().ServiceAccounts(api.NamespaceAll).Watch(options)
}, },
}, },
&api.ServiceAccount{}, &api.ServiceAccount{},
@@ -92,11 +93,11 @@ func NewTokensController(cl client.Interface, options TokensControllerOptions) *
&cache.ListWatch{ &cache.ListWatch{
ListFunc: func(options api.ListOptions) (runtime.Object, error) { ListFunc: func(options api.ListOptions) (runtime.Object, error) {
options.FieldSelector = tokenSelector options.FieldSelector = tokenSelector
return e.client.Secrets(api.NamespaceAll).List(options) return e.client.Legacy().Secrets(api.NamespaceAll).List(options)
}, },
WatchFunc: func(options api.ListOptions) (watch.Interface, error) { WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
options.FieldSelector = tokenSelector options.FieldSelector = tokenSelector
return e.client.Secrets(api.NamespaceAll).Watch(options) return e.client.Legacy().Secrets(api.NamespaceAll).Watch(options)
}, },
}, },
&api.Secret{}, &api.Secret{},
@@ -119,7 +120,7 @@ func NewTokensController(cl client.Interface, options TokensControllerOptions) *
type TokensController struct { type TokensController struct {
stopChan chan struct{} stopChan chan struct{}
client client.Interface client clientset.Interface
token serviceaccount.TokenGenerator token serviceaccount.TokenGenerator
rootCA []byte rootCA []byte
@@ -291,7 +292,7 @@ func (e *TokensController) createSecretIfNeeded(serviceAccount *api.ServiceAccou
func (e *TokensController) createSecret(serviceAccount *api.ServiceAccount) error { func (e *TokensController) createSecret(serviceAccount *api.ServiceAccount) error {
// We don't want to update the cache's copy of the service account // We don't want to update the cache's copy of the service account
// so add the secret to a freshly retrieved copy of the service account // so add the secret to a freshly retrieved copy of the service account
serviceAccounts := e.client.ServiceAccounts(serviceAccount.Namespace) serviceAccounts := e.client.Legacy().ServiceAccounts(serviceAccount.Namespace)
liveServiceAccount, err := serviceAccounts.Get(serviceAccount.Name) liveServiceAccount, err := serviceAccounts.Get(serviceAccount.Name)
if err != nil { if err != nil {
return err return err
@@ -329,7 +330,7 @@ func (e *TokensController) createSecret(serviceAccount *api.ServiceAccount) erro
} }
// Save the secret // Save the secret
if _, err := e.client.Secrets(serviceAccount.Namespace).Create(secret); err != nil { if _, err := e.client.Legacy().Secrets(serviceAccount.Namespace).Create(secret); err != nil {
return err return err
} }
@@ -339,7 +340,7 @@ func (e *TokensController) createSecret(serviceAccount *api.ServiceAccount) erro
if err != nil { if err != nil {
// we weren't able to use the token, try to clean it up. // we weren't able to use the token, try to clean it up.
glog.V(2).Infof("Deleting secret %s/%s because reference couldn't be added (%v)", secret.Namespace, secret.Name, err) glog.V(2).Infof("Deleting secret %s/%s because reference couldn't be added (%v)", secret.Namespace, secret.Name, err)
if err := e.client.Secrets(secret.Namespace).Delete(secret.Name); err != nil { if err := e.client.Legacy().Secrets(secret.Namespace).Delete(secret.Name, nil); err != nil {
glog.Error(err) // if we fail, just log it glog.Error(err) // if we fail, just log it
} }
} }
@@ -389,7 +390,7 @@ func (e *TokensController) generateTokenIfNeeded(serviceAccount *api.ServiceAcco
secret.Annotations[api.ServiceAccountUIDKey] = string(serviceAccount.UID) secret.Annotations[api.ServiceAccountUIDKey] = string(serviceAccount.UID)
// Save the secret // Save the secret
if _, err := e.client.Secrets(secret.Namespace).Update(secret); err != nil { if _, err := e.client.Legacy().Secrets(secret.Namespace).Update(secret); err != nil {
return err return err
} }
return nil return nil
@@ -397,7 +398,7 @@ func (e *TokensController) generateTokenIfNeeded(serviceAccount *api.ServiceAcco
// deleteSecret deletes the given secret // deleteSecret deletes the given secret
func (e *TokensController) deleteSecret(secret *api.Secret) error { func (e *TokensController) deleteSecret(secret *api.Secret) error {
return e.client.Secrets(secret.Namespace).Delete(secret.Name) return e.client.Legacy().Secrets(secret.Namespace).Delete(secret.Name, nil)
} }
// removeSecretReferenceIfNeeded updates the given ServiceAccount to remove a reference to the given secretName if needed. // removeSecretReferenceIfNeeded updates the given ServiceAccount to remove a reference to the given secretName if needed.
@@ -410,7 +411,7 @@ func (e *TokensController) removeSecretReferenceIfNeeded(serviceAccount *api.Ser
// We don't want to update the cache's copy of the service account // We don't want to update the cache's copy of the service account
// so remove the secret from a freshly retrieved copy of the service account // so remove the secret from a freshly retrieved copy of the service account
serviceAccounts := e.client.ServiceAccounts(serviceAccount.Namespace) serviceAccounts := e.client.Legacy().ServiceAccounts(serviceAccount.Namespace)
serviceAccount, err := serviceAccounts.Get(serviceAccount.Name) serviceAccount, err := serviceAccounts.Get(serviceAccount.Name)
if err != nil { if err != nil {
return err return err
@@ -460,7 +461,7 @@ func (e *TokensController) getServiceAccount(secret *api.Secret, fetchOnCacheMis
} }
if fetchOnCacheMiss { if fetchOnCacheMiss {
serviceAccount, err := e.client.ServiceAccounts(secret.Namespace).Get(name) serviceAccount, err := e.client.Legacy().ServiceAccounts(secret.Namespace).Get(name)
if apierrors.IsNotFound(err) { if apierrors.IsNotFound(err) {
return nil, nil return nil, nil
} }

147
pkg/controller/serviceaccount/tokens_controller_test.go
View File

@@ -21,7 +21,8 @@ import (
"testing" "testing"
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/client/unversioned/testclient" "k8s.io/kubernetes/pkg/client/testing/core"
"k8s.io/kubernetes/pkg/client/testing/fake"
"k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/runtime"
utilrand "k8s.io/kubernetes/pkg/util/rand" utilrand "k8s.io/kubernetes/pkg/util/rand"
) )
@@ -179,16 +180,16 @@ func TestTokenCreation(t *testing.T) {
UpdatedSecret *api.Secret UpdatedSecret *api.Secret
DeletedSecret *api.Secret DeletedSecret *api.Secret
ExpectedActions []testclient.Action ExpectedActions []core.Action
}{ }{
"new serviceaccount with no secrets": { "new serviceaccount with no secrets": {
ClientObjects: []runtime.Object{serviceAccount(emptySecretReferences()), createdTokenSecret()}, ClientObjects: []runtime.Object{serviceAccount(emptySecretReferences()), createdTokenSecret()},
AddedServiceAccount: serviceAccount(emptySecretReferences()), AddedServiceAccount: serviceAccount(emptySecretReferences()),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"), core.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"),
testclient.NewCreateAction("secrets", api.NamespaceDefault, createdTokenSecret()), core.NewCreateAction("secrets", api.NamespaceDefault, createdTokenSecret()),
testclient.NewUpdateAction("serviceaccounts", api.NamespaceDefault, serviceAccount(addTokenSecretReference(emptySecretReferences()))), core.NewUpdateAction("serviceaccounts", api.NamespaceDefault, serviceAccount(addTokenSecretReference(emptySecretReferences()))),
}, },
}, },
"new serviceaccount with no secrets with unsynced secret store": { "new serviceaccount with no secrets with unsynced secret store": {
@@ -197,20 +198,20 @@ func TestTokenCreation(t *testing.T) {
SecretsSyncPending: true, SecretsSyncPending: true,
AddedServiceAccount: serviceAccount(emptySecretReferences()), AddedServiceAccount: serviceAccount(emptySecretReferences()),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"), core.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"),
testclient.NewCreateAction("secrets", api.NamespaceDefault, createdTokenSecret()), core.NewCreateAction("secrets", api.NamespaceDefault, createdTokenSecret()),
testclient.NewUpdateAction("serviceaccounts", api.NamespaceDefault, serviceAccount(addTokenSecretReference(emptySecretReferences()))), core.NewUpdateAction("serviceaccounts", api.NamespaceDefault, serviceAccount(addTokenSecretReference(emptySecretReferences()))),
}, },
}, },
"new serviceaccount with missing secrets": { "new serviceaccount with missing secrets": {
ClientObjects: []runtime.Object{serviceAccount(missingSecretReferences()), createdTokenSecret()}, ClientObjects: []runtime.Object{serviceAccount(missingSecretReferences()), createdTokenSecret()},
AddedServiceAccount: serviceAccount(missingSecretReferences()), AddedServiceAccount: serviceAccount(missingSecretReferences()),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"), core.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"),
testclient.NewCreateAction("secrets", api.NamespaceDefault, createdTokenSecret()), core.NewCreateAction("secrets", api.NamespaceDefault, createdTokenSecret()),
testclient.NewUpdateAction("serviceaccounts", api.NamespaceDefault, serviceAccount(addTokenSecretReference(missingSecretReferences()))), core.NewUpdateAction("serviceaccounts", api.NamespaceDefault, serviceAccount(addTokenSecretReference(missingSecretReferences()))),
}, },
}, },
"new serviceaccount with missing secrets with unsynced secret store": { "new serviceaccount with missing secrets with unsynced secret store": {
@@ -219,16 +220,16 @@ func TestTokenCreation(t *testing.T) {
SecretsSyncPending: true, SecretsSyncPending: true,
AddedServiceAccount: serviceAccount(missingSecretReferences()), AddedServiceAccount: serviceAccount(missingSecretReferences()),
ExpectedActions: []testclient.Action{}, ExpectedActions: []core.Action{},
}, },
"new serviceaccount with non-token secrets": { "new serviceaccount with non-token secrets": {
ClientObjects: []runtime.Object{serviceAccount(regularSecretReferences()), createdTokenSecret(), opaqueSecret()}, ClientObjects: []runtime.Object{serviceAccount(regularSecretReferences()), createdTokenSecret(), opaqueSecret()},
AddedServiceAccount: serviceAccount(regularSecretReferences()), AddedServiceAccount: serviceAccount(regularSecretReferences()),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"), core.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"),
testclient.NewCreateAction("secrets", api.NamespaceDefault, createdTokenSecret()), core.NewCreateAction("secrets", api.NamespaceDefault, createdTokenSecret()),
testclient.NewUpdateAction("serviceaccounts", api.NamespaceDefault, serviceAccount(addTokenSecretReference(regularSecretReferences()))), core.NewUpdateAction("serviceaccounts", api.NamespaceDefault, serviceAccount(addTokenSecretReference(regularSecretReferences()))),
}, },
}, },
"new serviceaccount with token secrets": { "new serviceaccount with token secrets": {
@@ -236,14 +237,14 @@ func TestTokenCreation(t *testing.T) {
ExistingSecrets: []*api.Secret{serviceAccountTokenSecret()}, ExistingSecrets: []*api.Secret{serviceAccountTokenSecret()},
AddedServiceAccount: serviceAccount(tokenSecretReferences()), AddedServiceAccount: serviceAccount(tokenSecretReferences()),
ExpectedActions: []testclient.Action{}, ExpectedActions: []core.Action{},
}, },
"new serviceaccount with no secrets with resource conflict": { "new serviceaccount with no secrets with resource conflict": {
ClientObjects: []runtime.Object{updatedServiceAccount(emptySecretReferences()), createdTokenSecret()}, ClientObjects: []runtime.Object{updatedServiceAccount(emptySecretReferences()), createdTokenSecret()},
AddedServiceAccount: serviceAccount(emptySecretReferences()), AddedServiceAccount: serviceAccount(emptySecretReferences()),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"), core.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"),
}, },
}, },
@@ -251,10 +252,10 @@ func TestTokenCreation(t *testing.T) {
ClientObjects: []runtime.Object{serviceAccount(emptySecretReferences()), createdTokenSecret()}, ClientObjects: []runtime.Object{serviceAccount(emptySecretReferences()), createdTokenSecret()},
UpdatedServiceAccount: serviceAccount(emptySecretReferences()), UpdatedServiceAccount: serviceAccount(emptySecretReferences()),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"), core.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"),
testclient.NewCreateAction("secrets", api.NamespaceDefault, createdTokenSecret()), core.NewCreateAction("secrets", api.NamespaceDefault, createdTokenSecret()),
testclient.NewUpdateAction("serviceaccounts", api.NamespaceDefault, serviceAccount(addTokenSecretReference(emptySecretReferences()))), core.NewUpdateAction("serviceaccounts", api.NamespaceDefault, serviceAccount(addTokenSecretReference(emptySecretReferences()))),
}, },
}, },
"updated serviceaccount with no secrets with unsynced secret store": { "updated serviceaccount with no secrets with unsynced secret store": {
@@ -263,20 +264,20 @@ func TestTokenCreation(t *testing.T) {
SecretsSyncPending: true, SecretsSyncPending: true,
UpdatedServiceAccount: serviceAccount(emptySecretReferences()), UpdatedServiceAccount: serviceAccount(emptySecretReferences()),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"), core.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"),
testclient.NewCreateAction("secrets", api.NamespaceDefault, createdTokenSecret()), core.NewCreateAction("secrets", api.NamespaceDefault, createdTokenSecret()),
testclient.NewUpdateAction("serviceaccounts", api.NamespaceDefault, serviceAccount(addTokenSecretReference(emptySecretReferences()))), core.NewUpdateAction("serviceaccounts", api.NamespaceDefault, serviceAccount(addTokenSecretReference(emptySecretReferences()))),
}, },
}, },
"updated serviceaccount with missing secrets": { "updated serviceaccount with missing secrets": {
ClientObjects: []runtime.Object{serviceAccount(missingSecretReferences()), createdTokenSecret()}, ClientObjects: []runtime.Object{serviceAccount(missingSecretReferences()), createdTokenSecret()},
UpdatedServiceAccount: serviceAccount(missingSecretReferences()), UpdatedServiceAccount: serviceAccount(missingSecretReferences()),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"), core.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"),
testclient.NewCreateAction("secrets", api.NamespaceDefault, createdTokenSecret()), core.NewCreateAction("secrets", api.NamespaceDefault, createdTokenSecret()),
testclient.NewUpdateAction("serviceaccounts", api.NamespaceDefault, serviceAccount(addTokenSecretReference(missingSecretReferences()))), core.NewUpdateAction("serviceaccounts", api.NamespaceDefault, serviceAccount(addTokenSecretReference(missingSecretReferences()))),
}, },
}, },
"updated serviceaccount with missing secrets with unsynced secret store": { "updated serviceaccount with missing secrets with unsynced secret store": {
@@ -285,54 +286,54 @@ func TestTokenCreation(t *testing.T) {
SecretsSyncPending: true, SecretsSyncPending: true,
UpdatedServiceAccount: serviceAccount(missingSecretReferences()), UpdatedServiceAccount: serviceAccount(missingSecretReferences()),
ExpectedActions: []testclient.Action{}, ExpectedActions: []core.Action{},
}, },
"updated serviceaccount with non-token secrets": { "updated serviceaccount with non-token secrets": {
ClientObjects: []runtime.Object{serviceAccount(regularSecretReferences()), createdTokenSecret(), opaqueSecret()}, ClientObjects: []runtime.Object{serviceAccount(regularSecretReferences()), createdTokenSecret(), opaqueSecret()},
UpdatedServiceAccount: serviceAccount(regularSecretReferences()), UpdatedServiceAccount: serviceAccount(regularSecretReferences()),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"), core.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"),
testclient.NewCreateAction("secrets", api.NamespaceDefault, createdTokenSecret()), core.NewCreateAction("secrets", api.NamespaceDefault, createdTokenSecret()),
testclient.NewUpdateAction("serviceaccounts", api.NamespaceDefault, serviceAccount(addTokenSecretReference(regularSecretReferences()))), core.NewUpdateAction("serviceaccounts", api.NamespaceDefault, serviceAccount(addTokenSecretReference(regularSecretReferences()))),
}, },
}, },
"updated serviceaccount with token secrets": { "updated serviceaccount with token secrets": {
ExistingSecrets: []*api.Secret{serviceAccountTokenSecret()}, ExistingSecrets: []*api.Secret{serviceAccountTokenSecret()},
UpdatedServiceAccount: serviceAccount(tokenSecretReferences()), UpdatedServiceAccount: serviceAccount(tokenSecretReferences()),
ExpectedActions: []testclient.Action{}, ExpectedActions: []core.Action{},
}, },
"updated serviceaccount with no secrets with resource conflict": { "updated serviceaccount with no secrets with resource conflict": {
ClientObjects: []runtime.Object{updatedServiceAccount(emptySecretReferences()), createdTokenSecret()}, ClientObjects: []runtime.Object{updatedServiceAccount(emptySecretReferences()), createdTokenSecret()},
UpdatedServiceAccount: serviceAccount(emptySecretReferences()), UpdatedServiceAccount: serviceAccount(emptySecretReferences()),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"), core.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"),
}, },
}, },
"deleted serviceaccount with no secrets": { "deleted serviceaccount with no secrets": {
DeletedServiceAccount: serviceAccount(emptySecretReferences()), DeletedServiceAccount: serviceAccount(emptySecretReferences()),
ExpectedActions: []testclient.Action{}, ExpectedActions: []core.Action{},
}, },
"deleted serviceaccount with missing secrets": { "deleted serviceaccount with missing secrets": {
DeletedServiceAccount: serviceAccount(missingSecretReferences()), DeletedServiceAccount: serviceAccount(missingSecretReferences()),
ExpectedActions: []testclient.Action{}, ExpectedActions: []core.Action{},
}, },
"deleted serviceaccount with non-token secrets": { "deleted serviceaccount with non-token secrets": {
ClientObjects: []runtime.Object{opaqueSecret()}, ClientObjects: []runtime.Object{opaqueSecret()},
DeletedServiceAccount: serviceAccount(regularSecretReferences()), DeletedServiceAccount: serviceAccount(regularSecretReferences()),
ExpectedActions: []testclient.Action{}, ExpectedActions: []core.Action{},
}, },
"deleted serviceaccount with token secrets": { "deleted serviceaccount with token secrets": {
ClientObjects: []runtime.Object{serviceAccountTokenSecret()}, ClientObjects: []runtime.Object{serviceAccountTokenSecret()},
ExistingSecrets: []*api.Secret{serviceAccountTokenSecret()}, ExistingSecrets: []*api.Secret{serviceAccountTokenSecret()},
DeletedServiceAccount: serviceAccount(tokenSecretReferences()), DeletedServiceAccount: serviceAccount(tokenSecretReferences()),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewDeleteAction("secrets", api.NamespaceDefault, "token-secret-1"), core.NewDeleteAction("secrets", api.NamespaceDefault, "token-secret-1"),
}, },
}, },
@@ -340,24 +341,24 @@ func TestTokenCreation(t *testing.T) {
ClientObjects: []runtime.Object{serviceAccountTokenSecret()}, ClientObjects: []runtime.Object{serviceAccountTokenSecret()},
AddedSecret: serviceAccountTokenSecret(), AddedSecret: serviceAccountTokenSecret(),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"), core.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"),
testclient.NewDeleteAction("secrets", api.NamespaceDefault, "token-secret-1"), core.NewDeleteAction("secrets", api.NamespaceDefault, "token-secret-1"),
}, },
}, },
"added secret with serviceaccount": { "added secret with serviceaccount": {
ExistingServiceAccount: serviceAccount(tokenSecretReferences()), ExistingServiceAccount: serviceAccount(tokenSecretReferences()),
AddedSecret: serviceAccountTokenSecret(), AddedSecret: serviceAccountTokenSecret(),
ExpectedActions: []testclient.Action{}, ExpectedActions: []core.Action{},
}, },
"added token secret without token data": { "added token secret without token data": {
ClientObjects: []runtime.Object{serviceAccountTokenSecretWithoutTokenData()}, ClientObjects: []runtime.Object{serviceAccountTokenSecretWithoutTokenData()},
ExistingServiceAccount: serviceAccount(tokenSecretReferences()), ExistingServiceAccount: serviceAccount(tokenSecretReferences()),
AddedSecret: serviceAccountTokenSecretWithoutTokenData(), AddedSecret: serviceAccountTokenSecretWithoutTokenData(),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewUpdateAction("secrets", api.NamespaceDefault, serviceAccountTokenSecret()), core.NewUpdateAction("secrets", api.NamespaceDefault, serviceAccountTokenSecret()),
}, },
}, },
"added token secret without ca data": { "added token secret without ca data": {
@@ -365,8 +366,8 @@ func TestTokenCreation(t *testing.T) {
ExistingServiceAccount: serviceAccount(tokenSecretReferences()), ExistingServiceAccount: serviceAccount(tokenSecretReferences()),
AddedSecret: serviceAccountTokenSecretWithoutCAData(), AddedSecret: serviceAccountTokenSecretWithoutCAData(),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewUpdateAction("secrets", api.NamespaceDefault, serviceAccountTokenSecret()), core.NewUpdateAction("secrets", api.NamespaceDefault, serviceAccountTokenSecret()),
}, },
}, },
"added token secret with mismatched ca data": { "added token secret with mismatched ca data": {
@@ -374,8 +375,8 @@ func TestTokenCreation(t *testing.T) {
ExistingServiceAccount: serviceAccount(tokenSecretReferences()), ExistingServiceAccount: serviceAccount(tokenSecretReferences()),
AddedSecret: serviceAccountTokenSecretWithCAData([]byte("mismatched")), AddedSecret: serviceAccountTokenSecretWithCAData([]byte("mismatched")),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewUpdateAction("secrets", api.NamespaceDefault, serviceAccountTokenSecret()), core.NewUpdateAction("secrets", api.NamespaceDefault, serviceAccountTokenSecret()),
}, },
}, },
@@ -383,24 +384,24 @@ func TestTokenCreation(t *testing.T) {
ClientObjects: []runtime.Object{serviceAccountTokenSecret()}, ClientObjects: []runtime.Object{serviceAccountTokenSecret()},
UpdatedSecret: serviceAccountTokenSecret(), UpdatedSecret: serviceAccountTokenSecret(),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"), core.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"),
testclient.NewDeleteAction("secrets", api.NamespaceDefault, "token-secret-1"), core.NewDeleteAction("secrets", api.NamespaceDefault, "token-secret-1"),
}, },
}, },
"updated secret with serviceaccount": { "updated secret with serviceaccount": {
ExistingServiceAccount: serviceAccount(tokenSecretReferences()), ExistingServiceAccount: serviceAccount(tokenSecretReferences()),
UpdatedSecret: serviceAccountTokenSecret(), UpdatedSecret: serviceAccountTokenSecret(),
ExpectedActions: []testclient.Action{}, ExpectedActions: []core.Action{},
}, },
"updated token secret without token data": { "updated token secret without token data": {
ClientObjects: []runtime.Object{serviceAccountTokenSecretWithoutTokenData()}, ClientObjects: []runtime.Object{serviceAccountTokenSecretWithoutTokenData()},
ExistingServiceAccount: serviceAccount(tokenSecretReferences()), ExistingServiceAccount: serviceAccount(tokenSecretReferences()),
UpdatedSecret: serviceAccountTokenSecretWithoutTokenData(), UpdatedSecret: serviceAccountTokenSecretWithoutTokenData(),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewUpdateAction("secrets", api.NamespaceDefault, serviceAccountTokenSecret()), core.NewUpdateAction("secrets", api.NamespaceDefault, serviceAccountTokenSecret()),
}, },
}, },
"updated token secret without ca data": { "updated token secret without ca data": {
@@ -408,8 +409,8 @@ func TestTokenCreation(t *testing.T) {
ExistingServiceAccount: serviceAccount(tokenSecretReferences()), ExistingServiceAccount: serviceAccount(tokenSecretReferences()),
UpdatedSecret: serviceAccountTokenSecretWithoutCAData(), UpdatedSecret: serviceAccountTokenSecretWithoutCAData(),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewUpdateAction("secrets", api.NamespaceDefault, serviceAccountTokenSecret()), core.NewUpdateAction("secrets", api.NamespaceDefault, serviceAccountTokenSecret()),
}, },
}, },
"updated token secret with mismatched ca data": { "updated token secret with mismatched ca data": {
@@ -417,30 +418,30 @@ func TestTokenCreation(t *testing.T) {
ExistingServiceAccount: serviceAccount(tokenSecretReferences()), ExistingServiceAccount: serviceAccount(tokenSecretReferences()),
UpdatedSecret: serviceAccountTokenSecretWithCAData([]byte("mismatched")), UpdatedSecret: serviceAccountTokenSecretWithCAData([]byte("mismatched")),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewUpdateAction("secrets", api.NamespaceDefault, serviceAccountTokenSecret()), core.NewUpdateAction("secrets", api.NamespaceDefault, serviceAccountTokenSecret()),
}, },
}, },
"deleted secret without serviceaccount": { "deleted secret without serviceaccount": {
DeletedSecret: serviceAccountTokenSecret(), DeletedSecret: serviceAccountTokenSecret(),
ExpectedActions: []testclient.Action{}, ExpectedActions: []core.Action{},
}, },
"deleted secret with serviceaccount with reference": { "deleted secret with serviceaccount with reference": {
ClientObjects: []runtime.Object{serviceAccount(tokenSecretReferences())}, ClientObjects: []runtime.Object{serviceAccount(tokenSecretReferences())},
ExistingServiceAccount: serviceAccount(tokenSecretReferences()), ExistingServiceAccount: serviceAccount(tokenSecretReferences()),
DeletedSecret: serviceAccountTokenSecret(), DeletedSecret: serviceAccountTokenSecret(),
ExpectedActions: []testclient.Action{ ExpectedActions: []core.Action{
testclient.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"), core.NewGetAction("serviceaccounts", api.NamespaceDefault, "default"),
testclient.NewUpdateAction("serviceaccounts", api.NamespaceDefault, serviceAccount(emptySecretReferences())), core.NewUpdateAction("serviceaccounts", api.NamespaceDefault, serviceAccount(emptySecretReferences())),
}, },
}, },
"deleted secret with serviceaccount without reference": { "deleted secret with serviceaccount without reference": {
ExistingServiceAccount: serviceAccount(emptySecretReferences()), ExistingServiceAccount: serviceAccount(emptySecretReferences()),
DeletedSecret: serviceAccountTokenSecret(), DeletedSecret: serviceAccountTokenSecret(),
ExpectedActions: []testclient.Action{}, ExpectedActions: []core.Action{},
}, },
} }
@@ -451,7 +452,7 @@ func TestTokenCreation(t *testing.T) {
generator := &testGenerator{Token: "ABC"} generator := &testGenerator{Token: "ABC"}
client := testclient.NewSimpleFake(tc.ClientObjects...) client := fake.NewSimpleClientset(tc.ClientObjects...)
controller := NewTokensController(client, TokensControllerOptions{TokenGenerator: generator, RootCA: []byte("CA Data")}) controller := NewTokensController(client, TokensControllerOptions{TokenGenerator: generator, RootCA: []byte("CA Data")})

12
pkg/serviceaccount/jwt_test.go
View File

@@ -26,8 +26,8 @@ import (
"github.com/dgrijalva/jwt-go" "github.com/dgrijalva/jwt-go"
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
client "k8s.io/kubernetes/pkg/client/unversioned" clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
"k8s.io/kubernetes/pkg/client/unversioned/testclient" "k8s.io/kubernetes/pkg/client/testing/fake"
serviceaccountcontroller "k8s.io/kubernetes/pkg/controller/serviceaccount" serviceaccountcontroller "k8s.io/kubernetes/pkg/controller/serviceaccount"
"k8s.io/kubernetes/pkg/serviceaccount" "k8s.io/kubernetes/pkg/serviceaccount"
) )
@@ -159,7 +159,7 @@ func TestTokenGenerateAndValidate(t *testing.T) {
} }
testCases := map[string]struct { testCases := map[string]struct {
Client client.Interface Client clientset.Interface
Keys []*rsa.PublicKey Keys []*rsa.PublicKey
ExpectedErr bool ExpectedErr bool
@@ -199,7 +199,7 @@ func TestTokenGenerateAndValidate(t *testing.T) {
ExpectedGroups: []string{"system:serviceaccounts", "system:serviceaccounts:test"}, ExpectedGroups: []string{"system:serviceaccounts", "system:serviceaccounts:test"},
}, },
"valid lookup": { "valid lookup": {
Client: testclient.NewSimpleFake(serviceAccount, secret), Client: fake.NewSimpleClientset(serviceAccount, secret),
Keys: []*rsa.PublicKey{getPublicKey(publicKey)}, Keys: []*rsa.PublicKey{getPublicKey(publicKey)},
ExpectedErr: false, ExpectedErr: false,
ExpectedOK: true, ExpectedOK: true,
@@ -208,13 +208,13 @@ func TestTokenGenerateAndValidate(t *testing.T) {
ExpectedGroups: []string{"system:serviceaccounts", "system:serviceaccounts:test"}, ExpectedGroups: []string{"system:serviceaccounts", "system:serviceaccounts:test"},
}, },
"invalid secret lookup": { "invalid secret lookup": {
Client: testclient.NewSimpleFake(serviceAccount), Client: fake.NewSimpleClientset(serviceAccount),
Keys: []*rsa.PublicKey{getPublicKey(publicKey)}, Keys: []*rsa.PublicKey{getPublicKey(publicKey)},
ExpectedErr: true, ExpectedErr: true,
ExpectedOK: false, ExpectedOK: false,
}, },
"invalid serviceaccount lookup": { "invalid serviceaccount lookup": {
Client: testclient.NewSimpleFake(secret), Client: fake.NewSimpleClientset(secret),
Keys: []*rsa.PublicKey{getPublicKey(publicKey)}, Keys: []*rsa.PublicKey{getPublicKey(publicKey)},
ExpectedErr: true, ExpectedErr: true,
ExpectedOK: false, ExpectedOK: false,

10
test/integration/service_account_test.go
View File

@@ -38,6 +38,7 @@ import (
"k8s.io/kubernetes/pkg/auth/authenticator/bearertoken" "k8s.io/kubernetes/pkg/auth/authenticator/bearertoken"
"k8s.io/kubernetes/pkg/auth/authorizer" "k8s.io/kubernetes/pkg/auth/authorizer"
"k8s.io/kubernetes/pkg/auth/user" "k8s.io/kubernetes/pkg/auth/user"
clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
client "k8s.io/kubernetes/pkg/client/unversioned" client "k8s.io/kubernetes/pkg/client/unversioned"
serviceaccountcontroller "k8s.io/kubernetes/pkg/controller/serviceaccount" serviceaccountcontroller "k8s.io/kubernetes/pkg/controller/serviceaccount"
"k8s.io/kubernetes/pkg/master" "k8s.io/kubernetes/pkg/master"
@@ -347,8 +348,9 @@ func startServiceAccountTestServer(t *testing.T) (*client.Client, client.Config,
// Anonymous client config // Anonymous client config
clientConfig := client.Config{Host: apiServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}} clientConfig := client.Config{Host: apiServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}}
// Root client // Root client
// TODO: remove rootClient after we refactor pkg/admission to use the clientset.
rootClient := client.NewOrDie(&client.Config{Host: apiServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}, BearerToken: rootToken}) rootClient := client.NewOrDie(&client.Config{Host: apiServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}, BearerToken: rootToken})
rootClientset := clientset.FromUnversionedClient(rootClient)
// Set up two authenticators: // Set up two authenticators:
// 1. A token authenticator that maps the rootToken to the "root" user // 1. A token authenticator that maps the rootToken to the "root" user
// 2. A ServiceAccountToken authenticator that validates ServiceAccount tokens // 2. A ServiceAccountToken authenticator that validates ServiceAccount tokens
@@ -359,7 +361,7 @@ func startServiceAccountTestServer(t *testing.T) (*client.Client, client.Config,
return nil, false, nil return nil, false, nil
}) })
serviceAccountKey, _ := rsa.GenerateKey(rand.Reader, 2048) serviceAccountKey, _ := rsa.GenerateKey(rand.Reader, 2048)
serviceAccountTokenGetter := serviceaccountcontroller.NewGetterFromClient(rootClient) serviceAccountTokenGetter := serviceaccountcontroller.NewGetterFromClient(rootClientset)
serviceAccountTokenAuth := serviceaccount.JWTTokenAuthenticator([]*rsa.PublicKey{&serviceAccountKey.PublicKey}, true, serviceAccountTokenGetter) serviceAccountTokenAuth := serviceaccount.JWTTokenAuthenticator([]*rsa.PublicKey{&serviceAccountKey.PublicKey}, true, serviceAccountTokenGetter)
authenticator := union.New( authenticator := union.New(
bearertoken.New(rootTokenAuth), bearertoken.New(rootTokenAuth),
@@ -411,9 +413,9 @@ func startServiceAccountTestServer(t *testing.T) (*client.Client, client.Config,
m = master.New(masterConfig) m = master.New(masterConfig)
// Start the service account and service account token controllers // Start the service account and service account token controllers
tokenController := serviceaccountcontroller.NewTokensController(rootClient, serviceaccountcontroller.TokensControllerOptions{TokenGenerator: serviceaccount.JWTTokenGenerator(serviceAccountKey)}) tokenController := serviceaccountcontroller.NewTokensController(rootClientset, serviceaccountcontroller.TokensControllerOptions{TokenGenerator: serviceaccount.JWTTokenGenerator(serviceAccountKey)})
tokenController.Run() tokenController.Run()
serviceAccountController := serviceaccountcontroller.NewServiceAccountsController(rootClient, serviceaccountcontroller.DefaultServiceAccountsControllerOptions()) serviceAccountController := serviceaccountcontroller.NewServiceAccountsController(rootClientset, serviceaccountcontroller.DefaultServiceAccountsControllerOptions())
serviceAccountController.Run() serviceAccountController.Run()
// Start the admission plugin reflectors // Start the admission plugin reflectors
serviceAccountAdmission.Run() serviceAccountAdmission.Run()