From 4eadc5e97bc61768268dc83b83683bd862d8c89f Mon Sep 17 00:00:00 2001 From: Wojciech Tyczynski Date: Mon, 22 Feb 2016 10:15:22 +0100 Subject: [PATCH] Introduce RESTOptions to configure per-resource storage --- pkg/controller/serviceaccount/tokengetter.go | 4 +- pkg/master/master.go | 83 +++++++++++-------- pkg/registry/configmap/etcd/etcd.go | 7 +- pkg/registry/configmap/etcd/etcd_test.go | 3 +- pkg/registry/controller/etcd/etcd.go | 7 +- pkg/registry/controller/etcd/etcd_test.go | 3 +- pkg/registry/daemonset/etcd/etcd.go | 7 +- pkg/registry/daemonset/etcd/etcd_test.go | 3 +- pkg/registry/deployment/etcd/etcd.go | 10 +-- pkg/registry/deployment/etcd/etcd_test.go | 3 +- pkg/registry/endpoint/etcd/etcd.go | 7 +- pkg/registry/endpoint/etcd/etcd_test.go | 3 +- pkg/registry/event/etcd/etcd.go | 5 +- pkg/registry/event/etcd/etcd_test.go | 3 +- .../experimental/controller/etcd/etcd.go | 5 +- .../experimental/controller/etcd/etcd_test.go | 3 +- pkg/registry/generic/options.go | 27 ++++++ .../horizontalpodautoscaler/etcd/etcd.go | 7 +- .../horizontalpodautoscaler/etcd/etcd_test.go | 3 +- pkg/registry/ingress/etcd/etcd.go | 7 +- pkg/registry/ingress/etcd/etcd_test.go | 3 +- pkg/registry/job/etcd/etcd.go | 7 +- pkg/registry/job/etcd/etcd_test.go | 3 +- pkg/registry/limitrange/etcd/etcd.go | 7 +- pkg/registry/limitrange/etcd/etcd_test.go | 3 +- pkg/registry/namespace/etcd/etcd.go | 7 +- pkg/registry/namespace/etcd/etcd_test.go | 3 +- pkg/registry/node/etcd/etcd.go | 7 +- pkg/registry/node/etcd/etcd_test.go | 3 +- pkg/registry/persistentvolume/etcd/etcd.go | 7 +- .../persistentvolume/etcd/etcd_test.go | 3 +- .../persistentvolumeclaim/etcd/etcd.go | 7 +- .../persistentvolumeclaim/etcd/etcd_test.go | 3 +- pkg/registry/pod/etcd/etcd.go | 11 +-- pkg/registry/pod/etcd/etcd_test.go | 3 +- pkg/registry/podsecuritypolicy/etcd/etcd.go | 7 +- .../podsecuritypolicy/etcd/etcd_test.go | 3 +- pkg/registry/podtemplate/etcd/etcd.go | 7 +- pkg/registry/podtemplate/etcd/etcd_test.go | 3 +- pkg/registry/replicaset/etcd/etcd.go | 11 ++- pkg/registry/replicaset/etcd/etcd_test.go | 3 +- pkg/registry/resourcequota/etcd/etcd.go | 7 +- pkg/registry/resourcequota/etcd/etcd_test.go | 3 +- pkg/registry/secret/etcd/etcd.go | 7 +- pkg/registry/secret/etcd/etcd_test.go | 3 +- pkg/registry/service/etcd/etcd.go | 7 +- pkg/registry/service/etcd/etcd_test.go | 3 +- pkg/registry/serviceaccount/etcd/etcd.go | 7 +- pkg/registry/serviceaccount/etcd/etcd_test.go | 3 +- pkg/registry/thirdpartyresource/etcd/etcd.go | 5 +- .../thirdpartyresource/etcd/etcd_test.go | 3 +- .../thirdpartyresourcedata/etcd/etcd.go | 5 +- .../thirdpartyresourcedata/etcd/etcd_test.go | 3 +- 53 files changed, 201 insertions(+), 166 deletions(-) create mode 100644 pkg/registry/generic/options.go diff --git a/pkg/controller/serviceaccount/tokengetter.go b/pkg/controller/serviceaccount/tokengetter.go index e87fd9096d..c1d17f4895 100644 --- a/pkg/controller/serviceaccount/tokengetter.go +++ b/pkg/controller/serviceaccount/tokengetter.go @@ -71,7 +71,7 @@ func (r *registryGetter) GetSecret(namespace, name string) (*api.Secret, error) // uses the specified storage to retrieve service accounts and secrets. func NewGetterFromStorageInterface(s storage.Interface) serviceaccount.ServiceAccountTokenGetter { return NewGetterFromRegistries( - serviceaccountregistry.NewRegistry(serviceaccountetcd.NewREST(s, generic.UndecoratedStorage)), - secret.NewRegistry(secretetcd.NewREST(s, generic.UndecoratedStorage)), + serviceaccountregistry.NewRegistry(serviceaccountetcd.NewREST(generic.RESTOptions{s, generic.UndecoratedStorage})), + secret.NewRegistry(secretetcd.NewREST(generic.RESTOptions{s, generic.UndecoratedStorage})), ) } diff --git a/pkg/master/master.go b/pkg/master/master.go index 39d76bbfa7..1f4d7ae24b 100644 --- a/pkg/master/master.go +++ b/pkg/master/master.go @@ -324,38 +324,42 @@ func (m *Master) InstallAPIs(c *Config) { } func (m *Master) initV1ResourcesStorage(c *Config) { - storageDecorator := m.StorageDecorator() dbClient := func(resource string) storage.Interface { return c.StorageDestinations.Get("", resource) } + restOptions := func(resource string) generic.RESTOptions { + return generic.RESTOptions{ + Storage: dbClient(resource), + Decorator: m.StorageDecorator(), + } + } - podTemplateStorage := podtemplateetcd.NewREST(dbClient("podTemplates"), storageDecorator) + podTemplateStorage := podtemplateetcd.NewREST(restOptions("podTemplates")) - eventStorage := eventetcd.NewREST(dbClient("events"), storageDecorator, uint64(c.EventTTL.Seconds())) - limitRangeStorage := limitrangeetcd.NewREST(dbClient("limitRanges"), storageDecorator) + eventStorage := eventetcd.NewREST(restOptions("events"), uint64(c.EventTTL.Seconds())) + limitRangeStorage := limitrangeetcd.NewREST(restOptions("limitRanges")) - resourceQuotaStorage, resourceQuotaStatusStorage := resourcequotaetcd.NewREST(dbClient("resourceQuotas"), storageDecorator) - secretStorage := secretetcd.NewREST(dbClient("secrets"), storageDecorator) - serviceAccountStorage := serviceaccountetcd.NewREST(dbClient("serviceAccounts"), storageDecorator) - persistentVolumeStorage, persistentVolumeStatusStorage := pvetcd.NewREST(dbClient("persistentVolumes"), storageDecorator) - persistentVolumeClaimStorage, persistentVolumeClaimStatusStorage := pvcetcd.NewREST(dbClient("persistentVolumeClaims"), storageDecorator) - configMapStorage := configmapetcd.NewREST(dbClient("configMaps"), storageDecorator) + resourceQuotaStorage, resourceQuotaStatusStorage := resourcequotaetcd.NewREST(restOptions("resourceQuotas")) + secretStorage := secretetcd.NewREST(restOptions("secrets")) + serviceAccountStorage := serviceaccountetcd.NewREST(restOptions("serviceAccounts")) + persistentVolumeStorage, persistentVolumeStatusStorage := pvetcd.NewREST(restOptions("persistentVolumes")) + persistentVolumeClaimStorage, persistentVolumeClaimStatusStorage := pvcetcd.NewREST(restOptions("persistentVolumeClaims")) + configMapStorage := configmapetcd.NewREST(restOptions("configMaps")) - namespaceStorage, namespaceStatusStorage, namespaceFinalizeStorage := namespaceetcd.NewREST(dbClient("namespaces"), storageDecorator) + namespaceStorage, namespaceStatusStorage, namespaceFinalizeStorage := namespaceetcd.NewREST(restOptions("namespaces")) m.namespaceRegistry = namespace.NewRegistry(namespaceStorage) - endpointsStorage := endpointsetcd.NewREST(dbClient("endpoints"), storageDecorator) + endpointsStorage := endpointsetcd.NewREST(restOptions("endpoints")) m.endpointRegistry = endpoint.NewRegistry(endpointsStorage) - nodeStorage := nodeetcd.NewStorage(dbClient("nodes"), storageDecorator, c.KubeletClient, m.ProxyTransport) + nodeStorage := nodeetcd.NewStorage(restOptions("nodes"), c.KubeletClient, m.ProxyTransport) m.nodeRegistry = node.NewRegistry(nodeStorage.Node) podStorage := podetcd.NewStorage( - dbClient("pods"), - storageDecorator, + restOptions("pods"), kubeletclient.ConnectionInfoGetter(nodeStorage.Node), m.ProxyTransport, ) - serviceStorage, serviceStatusStorage := serviceetcd.NewREST(dbClient("services"), storageDecorator) + serviceStorage, serviceStatusStorage := serviceetcd.NewREST(restOptions("services")) m.serviceRegistry = service.NewRegistry(serviceStorage) var serviceClusterIPRegistry service.RangeRegistry @@ -381,7 +385,7 @@ func (m *Master) initV1ResourcesStorage(c *Config) { }) m.serviceNodePortAllocator = serviceNodePortRegistry - controllerStorage, controllerStatusStorage := controlleretcd.NewREST(dbClient("replicationControllers"), storageDecorator) + controllerStorage, controllerStatusStorage := controlleretcd.NewREST(restOptions("replicationControllers")) serviceRest := service.NewStorage(m.serviceRegistry, m.endpointRegistry, serviceClusterIPAllocator, serviceNodePortAllocator, m.ProxyTransport) @@ -608,7 +612,7 @@ func (m *Master) InstallThirdPartyResource(rsrc *extensions.ThirdPartyResource) } func (m *Master) thirdpartyapi(group, kind, version string) *apiserver.APIGroupVersion { - resourceStorage := thirdpartyresourcedataetcd.NewREST(m.thirdPartyStorage, generic.UndecoratedStorage, group, kind) + resourceStorage := thirdpartyresourcedataetcd.NewREST(generic.RESTOptions{m.thirdPartyStorage, generic.UndecoratedStorage}, group, kind) apiRoot := makeThirdPartyPath("") @@ -656,20 +660,23 @@ func (m *Master) getExtensionResources(c *Config) map[string]rest.Storage { } return enabled } - storageDecorator := m.StorageDecorator() - dbClient := func(resource string) storage.Interface { - return c.StorageDestinations.Get(extensions.GroupName, resource) + restOptions := func(resource string) generic.RESTOptions { + return generic.RESTOptions{ + Storage: c.StorageDestinations.Get(extensions.GroupName, resource), + Decorator: m.StorageDecorator(), + } } storage := map[string]rest.Storage{} if isEnabled("horizontalpodautoscalers") { m.constructHPAResources(c, storage) - controllerStorage := expcontrolleretcd.NewStorage(c.StorageDestinations.Get("", "replicationControllers"), storageDecorator) + controllerStorage := expcontrolleretcd.NewStorage( + generic.RESTOptions{c.StorageDestinations.Get("", "replicationControllers"), m.StorageDecorator()}) storage["replicationcontrollers"] = controllerStorage.ReplicationController storage["replicationcontrollers/scale"] = controllerStorage.Scale } if isEnabled("thirdpartyresources") { - thirdPartyResourceStorage := thirdpartyresourceetcd.NewREST(dbClient("thirdpartyresources"), storageDecorator) + thirdPartyResourceStorage := thirdpartyresourceetcd.NewREST(restOptions("thirdpartyresources")) thirdPartyControl := ThirdPartyController{ master: m, thirdPartyResourceRegistry: thirdPartyResourceStorage, @@ -686,12 +693,12 @@ func (m *Master) getExtensionResources(c *Config) map[string]rest.Storage { } if isEnabled("daemonsets") { - daemonSetStorage, daemonSetStatusStorage := daemonetcd.NewREST(dbClient("daemonsets"), storageDecorator) + daemonSetStorage, daemonSetStatusStorage := daemonetcd.NewREST(restOptions("daemonsets")) storage["daemonsets"] = daemonSetStorage storage["daemonsets/status"] = daemonSetStatusStorage } if isEnabled("deployments") { - deploymentStorage := deploymentetcd.NewStorage(dbClient("deployments"), storageDecorator) + deploymentStorage := deploymentetcd.NewStorage(restOptions("deployments")) storage["deployments"] = deploymentStorage.Deployment storage["deployments/status"] = deploymentStorage.Status // TODO(madhusudancs): Install scale when Scale group issues are fixed (see issue #18528). @@ -702,16 +709,16 @@ func (m *Master) getExtensionResources(c *Config) map[string]rest.Storage { m.constructJobResources(c, storage) } if isEnabled("ingresses") { - ingressStorage, ingressStatusStorage := ingressetcd.NewREST(dbClient("ingresses"), storageDecorator) + ingressStorage, ingressStatusStorage := ingressetcd.NewREST(restOptions("ingresses")) storage["ingresses"] = ingressStorage storage["ingresses/status"] = ingressStatusStorage } if isEnabled("podsecuritypolicy") { - podSecurityPolicyStorage := pspetcd.NewREST(dbClient("podsecuritypolicy"), storageDecorator) + podSecurityPolicyStorage := pspetcd.NewREST(restOptions("podsecuritypolicy")) storage["podSecurityPolicies"] = podSecurityPolicyStorage } if isEnabled("replicasets") { - replicaSetStorage := replicasetetcd.NewStorage(dbClient("replicasets"), storageDecorator) + replicaSetStorage := replicasetetcd.NewStorage(restOptions("replicasets")) storage["replicasets"] = replicaSetStorage.ReplicaSet storage["replicasets/status"] = replicaSetStorage.Status } @@ -726,11 +733,13 @@ func (m *Master) constructHPAResources(c *Config, restStorage map[string]rest.St // Note that hpa's storage settings are changed by changing the autoscaling // group. Clearly we want all hpas to be stored in the same place no // matter where they're accessed from. - storageDecorator := m.StorageDecorator() - dbClient := func(resource string) storage.Interface { - return c.StorageDestinations.Search([]string{autoscaling.GroupName, extensions.GroupName}, resource) + restOptions := func(resource string) generic.RESTOptions { + return generic.RESTOptions{ + Storage: c.StorageDestinations.Search([]string{autoscaling.GroupName, extensions.GroupName}, resource), + Decorator: m.StorageDecorator(), + } } - autoscalerStorage, autoscalerStatusStorage := horizontalpodautoscaleretcd.NewREST(dbClient("horizontalpodautoscalers"), storageDecorator) + autoscalerStorage, autoscalerStatusStorage := horizontalpodautoscaleretcd.NewREST(restOptions("horizontalpodautoscalers")) restStorage["horizontalpodautoscalers"] = autoscalerStorage restStorage["horizontalpodautoscalers/status"] = autoscalerStatusStorage } @@ -760,11 +769,13 @@ func (m *Master) constructJobResources(c *Config, restStorage map[string]rest.St // Note that job's storage settings are changed by changing the batch // group. Clearly we want all jobs to be stored in the same place no // matter where they're accessed from. - storageDecorator := m.StorageDecorator() - dbClient := func(resource string) storage.Interface { - return c.StorageDestinations.Search([]string{batch.GroupName, extensions.GroupName}, resource) + restOptions := func(resource string) generic.RESTOptions { + return generic.RESTOptions{ + Storage: c.StorageDestinations.Search([]string{batch.GroupName, extensions.GroupName}, resource), + Decorator: m.StorageDecorator(), + } } - jobStorage, jobStatusStorage := jobetcd.NewREST(dbClient("jobs"), storageDecorator) + jobStorage, jobStatusStorage := jobetcd.NewREST(restOptions("jobs")) restStorage["jobs"] = jobStorage restStorage["jobs/status"] = jobStatusStorage } diff --git a/pkg/registry/configmap/etcd/etcd.go b/pkg/registry/configmap/etcd/etcd.go index edfe2c4674..0b81f778a2 100644 --- a/pkg/registry/configmap/etcd/etcd.go +++ b/pkg/registry/configmap/etcd/etcd.go @@ -21,7 +21,6 @@ import ( "k8s.io/kubernetes/pkg/registry/configmap" "k8s.io/kubernetes/pkg/registry/generic" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" ) @@ -32,12 +31,12 @@ type REST struct { } // NewREST returns a RESTStorage object that will work with ConfigMap objects. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) *REST { +func NewREST(opts generic.RESTOptions) *REST { prefix := "/configmaps" newListFunc := func() runtime.Object { return &api.ConfigMapList{} } - storageInterface := storageDecorator( - s, 100, &api.ConfigMap{}, prefix, configmap.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, 100, &api.ConfigMap{}, prefix, configmap.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { diff --git a/pkg/registry/configmap/etcd/etcd_test.go b/pkg/registry/configmap/etcd/etcd_test.go index 285917fefe..ad2daa7841 100644 --- a/pkg/registry/configmap/etcd/etcd_test.go +++ b/pkg/registry/configmap/etcd/etcd_test.go @@ -30,7 +30,8 @@ import ( func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, "") - return NewREST(etcdStorage, generic.UndecoratedStorage), server + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + return NewREST(restOptions), server } func validNewConfigMap() *api.ConfigMap { diff --git a/pkg/registry/controller/etcd/etcd.go b/pkg/registry/controller/etcd/etcd.go index 92c6c81399..a03bf6a098 100644 --- a/pkg/registry/controller/etcd/etcd.go +++ b/pkg/registry/controller/etcd/etcd.go @@ -27,7 +27,6 @@ import ( "k8s.io/kubernetes/pkg/registry/generic" etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) type REST struct { @@ -35,12 +34,12 @@ type REST struct { } // NewREST returns a RESTStorage object that will work against replication controllers. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) { +func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) { prefix := "/controllers" newListFunc := func() runtime.Object { return &api.ReplicationControllerList{} } - storageInterface := storageDecorator( - s, cachesize.GetWatchCacheSizeByResource(cachesize.Controllers), &api.ReplicationController{}, prefix, controller.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Controllers), &api.ReplicationController{}, prefix, controller.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &api.ReplicationController{} }, diff --git a/pkg/registry/controller/etcd/etcd_test.go b/pkg/registry/controller/etcd/etcd_test.go index 287292f50e..33d2d8becd 100644 --- a/pkg/registry/controller/etcd/etcd_test.go +++ b/pkg/registry/controller/etcd/etcd_test.go @@ -30,7 +30,8 @@ import ( func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, "") - controllerStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + controllerStorage, statusStorage := NewREST(restOptions) return controllerStorage, statusStorage, server } diff --git a/pkg/registry/daemonset/etcd/etcd.go b/pkg/registry/daemonset/etcd/etcd.go index bde8d555af..61fcbcb4b3 100644 --- a/pkg/registry/daemonset/etcd/etcd.go +++ b/pkg/registry/daemonset/etcd/etcd.go @@ -26,7 +26,6 @@ import ( "k8s.io/kubernetes/pkg/registry/generic" etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) // rest implements a RESTStorage for DaemonSets against etcd @@ -35,12 +34,12 @@ type REST struct { } // NewREST returns a RESTStorage object that will work against DaemonSets. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) { +func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) { prefix := "/daemonsets" newListFunc := func() runtime.Object { return &extensions.DaemonSetList{} } - storageInterface := storageDecorator( - s, cachesize.GetWatchCacheSizeByResource(cachesize.Daemonsets), &extensions.DaemonSet{}, prefix, daemonset.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Daemonsets), &extensions.DaemonSet{}, prefix, daemonset.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &extensions.DaemonSet{} }, diff --git a/pkg/registry/daemonset/etcd/etcd_test.go b/pkg/registry/daemonset/etcd/etcd_test.go index 933f8344c4..fdb8850951 100755 --- a/pkg/registry/daemonset/etcd/etcd_test.go +++ b/pkg/registry/daemonset/etcd/etcd_test.go @@ -32,7 +32,8 @@ import ( func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, extensions.GroupName) - daemonSetStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + daemonSetStorage, statusStorage := NewREST(restOptions) return daemonSetStorage, statusStorage, server } diff --git a/pkg/registry/deployment/etcd/etcd.go b/pkg/registry/deployment/etcd/etcd.go index 5c2ae3fee7..0b7bf6fbdb 100644 --- a/pkg/registry/deployment/etcd/etcd.go +++ b/pkg/registry/deployment/etcd/etcd.go @@ -43,8 +43,8 @@ type DeploymentStorage struct { Rollback *RollbackREST } -func NewStorage(s storage.Interface, storageDecorator generic.StorageDecorator) DeploymentStorage { - deploymentRest, deploymentStatusRest, deploymentRollbackRest := NewREST(s, storageDecorator) +func NewStorage(opts generic.RESTOptions) DeploymentStorage { + deploymentRest, deploymentStatusRest, deploymentRollbackRest := NewREST(opts) deploymentRegistry := deployment.NewRegistry(deploymentRest) return DeploymentStorage{ @@ -60,12 +60,12 @@ type REST struct { } // NewREST returns a RESTStorage object that will work against deployments. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST, *RollbackREST) { +func NewREST(opts generic.RESTOptions) (*REST, *StatusREST, *RollbackREST) { prefix := "/deployments" newListFunc := func() runtime.Object { return &extensions.DeploymentList{} } - storageInterface := storageDecorator( - s, cachesize.GetWatchCacheSizeByResource(cachesize.Deployments), &extensions.Deployment{}, prefix, deployment.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Deployments), &extensions.Deployment{}, prefix, deployment.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &extensions.Deployment{} }, diff --git a/pkg/registry/deployment/etcd/etcd_test.go b/pkg/registry/deployment/etcd/etcd_test.go index 66520862d7..fe2d1f2a66 100644 --- a/pkg/registry/deployment/etcd/etcd_test.go +++ b/pkg/registry/deployment/etcd/etcd_test.go @@ -36,7 +36,8 @@ import ( func newStorage(t *testing.T) (*DeploymentStorage, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, extensions.GroupName) - deploymentStorage := NewStorage(etcdStorage, generic.UndecoratedStorage) + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + deploymentStorage := NewStorage(restOptions) return &deploymentStorage, server } diff --git a/pkg/registry/endpoint/etcd/etcd.go b/pkg/registry/endpoint/etcd/etcd.go index 0b7e4f7c06..3facdee650 100644 --- a/pkg/registry/endpoint/etcd/etcd.go +++ b/pkg/registry/endpoint/etcd/etcd.go @@ -25,7 +25,6 @@ import ( "k8s.io/kubernetes/pkg/registry/generic" etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) type REST struct { @@ -33,12 +32,12 @@ type REST struct { } // NewREST returns a RESTStorage object that will work against endpoints. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) *REST { +func NewREST(opts generic.RESTOptions) *REST { prefix := "/services/endpoints" newListFunc := func() runtime.Object { return &api.EndpointsList{} } - storageInterface := storageDecorator( - s, cachesize.GetWatchCacheSizeByResource(cachesize.Endpoints), &api.Endpoints{}, prefix, endpoint.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Endpoints), &api.Endpoints{}, prefix, endpoint.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &api.Endpoints{} }, diff --git a/pkg/registry/endpoint/etcd/etcd_test.go b/pkg/registry/endpoint/etcd/etcd_test.go index 43633c395a..7f52665c9c 100644 --- a/pkg/registry/endpoint/etcd/etcd_test.go +++ b/pkg/registry/endpoint/etcd/etcd_test.go @@ -30,7 +30,8 @@ import ( func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, "") - return NewREST(etcdStorage, generic.UndecoratedStorage), server + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + return NewREST(restOptions), server } func validNewEndpoints() *api.Endpoints { diff --git a/pkg/registry/event/etcd/etcd.go b/pkg/registry/event/etcd/etcd.go index d6c405d3a8..db324a80f5 100644 --- a/pkg/registry/event/etcd/etcd.go +++ b/pkg/registry/event/etcd/etcd.go @@ -24,7 +24,6 @@ import ( "k8s.io/kubernetes/pkg/registry/generic" etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) type REST struct { @@ -32,12 +31,12 @@ type REST struct { } // NewREST returns a RESTStorage object that will work against events. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator, ttl uint64) *REST { +func NewREST(opts generic.RESTOptions, ttl uint64) *REST { prefix := "/events" // We explicitly do NOT do any decoration here - switching on Cacher // for events will lead to too high memory consumption. - storageInterface := s + storageInterface := opts.Storage store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &api.Event{} }, diff --git a/pkg/registry/event/etcd/etcd_test.go b/pkg/registry/event/etcd/etcd_test.go index 88d3a62f4e..0a0d17e5c1 100644 --- a/pkg/registry/event/etcd/etcd_test.go +++ b/pkg/registry/event/etcd/etcd_test.go @@ -30,7 +30,8 @@ var testTTL uint64 = 60 func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, "") - return NewREST(etcdStorage, generic.UndecoratedStorage, testTTL), server + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + return NewREST(restOptions, testTTL), server } func validNewEvent(namespace string) *api.Event { diff --git a/pkg/registry/experimental/controller/etcd/etcd.go b/pkg/registry/experimental/controller/etcd/etcd.go index 39611c3e53..f26f39fd0e 100644 --- a/pkg/registry/experimental/controller/etcd/etcd.go +++ b/pkg/registry/experimental/controller/etcd/etcd.go @@ -23,7 +23,6 @@ import ( "k8s.io/kubernetes/pkg/api/errors" "k8s.io/kubernetes/pkg/api/rest" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" "k8s.io/kubernetes/pkg/registry/controller" "k8s.io/kubernetes/pkg/registry/controller/etcd" @@ -40,9 +39,9 @@ type ContainerStorage struct { Scale *ScaleREST } -func NewStorage(s storage.Interface, storageDecorator generic.StorageDecorator) ContainerStorage { +func NewStorage(opts generic.RESTOptions) ContainerStorage { // scale does not set status, only updates spec so we ignore the status - controllerREST, _ := etcd.NewREST(s, storageDecorator) + controllerREST, _ := etcd.NewREST(opts) rcRegistry := controller.NewRegistry(controllerREST) return ContainerStorage{ diff --git a/pkg/registry/experimental/controller/etcd/etcd_test.go b/pkg/registry/experimental/controller/etcd/etcd_test.go index 97cec58070..1ee7e5749f 100644 --- a/pkg/registry/experimental/controller/etcd/etcd_test.go +++ b/pkg/registry/experimental/controller/etcd/etcd_test.go @@ -30,7 +30,8 @@ import ( func newStorage(t *testing.T) (*ScaleREST, *etcdtesting.EtcdTestServer, storage.Interface) { etcdStorage, server := registrytest.NewEtcdStorage(t, "") - return NewStorage(etcdStorage, generic.UndecoratedStorage).Scale, server, etcdStorage + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + return NewStorage(restOptions).Scale, server, etcdStorage } var validPodTemplate = api.PodTemplate{ diff --git a/pkg/registry/generic/options.go b/pkg/registry/generic/options.go new file mode 100644 index 0000000000..ad9300cdf6 --- /dev/null +++ b/pkg/registry/generic/options.go @@ -0,0 +1,27 @@ +/* +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 generic + +import ( + pkgstorage "k8s.io/kubernetes/pkg/storage" +) + +// RESTOptions is set of configuration options to generic registries. +type RESTOptions struct { + Storage pkgstorage.Interface + Decorator StorageDecorator +} diff --git a/pkg/registry/horizontalpodautoscaler/etcd/etcd.go b/pkg/registry/horizontalpodautoscaler/etcd/etcd.go index 3686266f32..39a3772b70 100644 --- a/pkg/registry/horizontalpodautoscaler/etcd/etcd.go +++ b/pkg/registry/horizontalpodautoscaler/etcd/etcd.go @@ -26,7 +26,6 @@ import ( etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" "k8s.io/kubernetes/pkg/registry/horizontalpodautoscaler" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) type REST struct { @@ -34,12 +33,12 @@ type REST struct { } // NewREST returns a RESTStorage object that will work against horizontal pod autoscalers. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) { +func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) { prefix := "/horizontalpodautoscalers" newListFunc := func() runtime.Object { return &extensions.HorizontalPodAutoscalerList{} } - storageInterface := storageDecorator( - s, cachesize.GetWatchCacheSizeByResource(cachesize.HorizontalPodAutoscalers), &extensions.HorizontalPodAutoscaler{}, prefix, horizontalpodautoscaler.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.HorizontalPodAutoscalers), &extensions.HorizontalPodAutoscaler{}, prefix, horizontalpodautoscaler.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &extensions.HorizontalPodAutoscaler{} }, diff --git a/pkg/registry/horizontalpodautoscaler/etcd/etcd_test.go b/pkg/registry/horizontalpodautoscaler/etcd/etcd_test.go index eb9392572a..37f3f30408 100644 --- a/pkg/registry/horizontalpodautoscaler/etcd/etcd_test.go +++ b/pkg/registry/horizontalpodautoscaler/etcd/etcd_test.go @@ -33,7 +33,8 @@ import ( func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, extensions.GroupName) - horizontalPodAutoscalerStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + horizontalPodAutoscalerStorage, statusStorage := NewREST(restOptions) return horizontalPodAutoscalerStorage, statusStorage, server } diff --git a/pkg/registry/ingress/etcd/etcd.go b/pkg/registry/ingress/etcd/etcd.go index 5932b09cd5..b5eff10a6b 100644 --- a/pkg/registry/ingress/etcd/etcd.go +++ b/pkg/registry/ingress/etcd/etcd.go @@ -26,7 +26,6 @@ import ( etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" ingress "k8s.io/kubernetes/pkg/registry/ingress" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) // rest implements a RESTStorage for replication controllers against etcd @@ -35,12 +34,12 @@ type REST struct { } // NewREST returns a RESTStorage object that will work against replication controllers. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) { +func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) { prefix := "/ingress" newListFunc := func() runtime.Object { return &extensions.IngressList{} } - storageInterface := storageDecorator( - s, cachesize.GetWatchCacheSizeByResource(cachesize.Ingress), &extensions.Ingress{}, prefix, ingress.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Ingress), &extensions.Ingress{}, prefix, ingress.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &extensions.Ingress{} }, diff --git a/pkg/registry/ingress/etcd/etcd_test.go b/pkg/registry/ingress/etcd/etcd_test.go index 9de1113882..b2b8fe2eca 100755 --- a/pkg/registry/ingress/etcd/etcd_test.go +++ b/pkg/registry/ingress/etcd/etcd_test.go @@ -32,7 +32,8 @@ import ( func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, extensions.GroupName) - ingressStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + ingressStorage, statusStorage := NewREST(restOptions) return ingressStorage, statusStorage, server } diff --git a/pkg/registry/job/etcd/etcd.go b/pkg/registry/job/etcd/etcd.go index fbf3a0d7a3..9f2a40777c 100644 --- a/pkg/registry/job/etcd/etcd.go +++ b/pkg/registry/job/etcd/etcd.go @@ -26,7 +26,6 @@ import ( etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" "k8s.io/kubernetes/pkg/registry/job" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) // REST implements a RESTStorage for jobs against etcd @@ -35,12 +34,12 @@ type REST struct { } // NewREST returns a RESTStorage object that will work against Jobs. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) { +func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) { prefix := "/jobs" newListFunc := func() runtime.Object { return &extensions.JobList{} } - storageInterface := storageDecorator( - s, cachesize.GetWatchCacheSizeByResource(cachesize.Jobs), &extensions.Job{}, prefix, job.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Jobs), &extensions.Job{}, prefix, job.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &extensions.Job{} }, diff --git a/pkg/registry/job/etcd/etcd_test.go b/pkg/registry/job/etcd/etcd_test.go index 73700651f1..623125e8a6 100644 --- a/pkg/registry/job/etcd/etcd_test.go +++ b/pkg/registry/job/etcd/etcd_test.go @@ -34,7 +34,8 @@ import ( func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, extensions.GroupName) - jobStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + jobStorage, statusStorage := NewREST(restOptions) return jobStorage, statusStorage, server } diff --git a/pkg/registry/limitrange/etcd/etcd.go b/pkg/registry/limitrange/etcd/etcd.go index f42ee56ddc..32bc6d6454 100644 --- a/pkg/registry/limitrange/etcd/etcd.go +++ b/pkg/registry/limitrange/etcd/etcd.go @@ -25,7 +25,6 @@ import ( etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" "k8s.io/kubernetes/pkg/registry/limitrange" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) type REST struct { @@ -33,12 +32,12 @@ type REST struct { } // NewREST returns a RESTStorage object that will work against horizontal pod autoscalers. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) *REST { +func NewREST(opts generic.RESTOptions) *REST { prefix := "/limitranges" newListFunc := func() runtime.Object { return &api.LimitRangeList{} } - storageInterface := storageDecorator( - s, cachesize.GetWatchCacheSizeByResource(cachesize.LimitRanges), &api.LimitRange{}, prefix, limitrange.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.LimitRanges), &api.LimitRange{}, prefix, limitrange.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &api.LimitRange{} }, diff --git a/pkg/registry/limitrange/etcd/etcd_test.go b/pkg/registry/limitrange/etcd/etcd_test.go index 4567e9fd73..6c5b6e60a8 100644 --- a/pkg/registry/limitrange/etcd/etcd_test.go +++ b/pkg/registry/limitrange/etcd/etcd_test.go @@ -31,7 +31,8 @@ import ( func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, "") - return NewREST(etcdStorage, generic.UndecoratedStorage), server + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + return NewREST(restOptions), server } func validNewLimitRange() *api.LimitRange { diff --git a/pkg/registry/namespace/etcd/etcd.go b/pkg/registry/namespace/etcd/etcd.go index deb161c424..c09048a29b 100644 --- a/pkg/registry/namespace/etcd/etcd.go +++ b/pkg/registry/namespace/etcd/etcd.go @@ -29,7 +29,6 @@ import ( etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" "k8s.io/kubernetes/pkg/registry/namespace" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) // rest implements a RESTStorage for namespaces against etcd @@ -49,12 +48,12 @@ type FinalizeREST struct { } // NewREST returns a RESTStorage object that will work against namespaces. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST, *FinalizeREST) { +func NewREST(opts generic.RESTOptions) (*REST, *StatusREST, *FinalizeREST) { prefix := "/namespaces" newListFunc := func() runtime.Object { return &api.NamespaceList{} } - storageInterface := storageDecorator( - s, cachesize.GetWatchCacheSizeByResource(cachesize.Namespaces), &api.Namespace{}, prefix, namespace.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Namespaces), &api.Namespace{}, prefix, namespace.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &api.Namespace{} }, diff --git a/pkg/registry/namespace/etcd/etcd_test.go b/pkg/registry/namespace/etcd/etcd_test.go index f591056ba3..afd8c6b761 100644 --- a/pkg/registry/namespace/etcd/etcd_test.go +++ b/pkg/registry/namespace/etcd/etcd_test.go @@ -31,7 +31,8 @@ import ( func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, "") - namespaceStorage, _, _ := NewREST(etcdStorage, generic.UndecoratedStorage) + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + namespaceStorage, _, _ := NewREST(restOptions) return namespaceStorage, server } diff --git a/pkg/registry/node/etcd/etcd.go b/pkg/registry/node/etcd/etcd.go index 78b71f44dc..e0ee832b9f 100644 --- a/pkg/registry/node/etcd/etcd.go +++ b/pkg/registry/node/etcd/etcd.go @@ -30,7 +30,6 @@ import ( "k8s.io/kubernetes/pkg/registry/node" noderest "k8s.io/kubernetes/pkg/registry/node/rest" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) // NodeStorage includes storage for nodes and all sub resources @@ -61,12 +60,12 @@ func (r *StatusREST) Update(ctx api.Context, obj runtime.Object) (runtime.Object } // NewREST returns a RESTStorage object that will work against nodes. -func NewStorage(s storage.Interface, storageDecorator generic.StorageDecorator, connection client.ConnectionInfoGetter, proxyTransport http.RoundTripper) NodeStorage { +func NewStorage(opts generic.RESTOptions, connection client.ConnectionInfoGetter, proxyTransport http.RoundTripper) NodeStorage { prefix := "/minions" newListFunc := func() runtime.Object { return &api.NodeList{} } - storageInterface := storageDecorator( - s, cachesize.GetWatchCacheSizeByResource(cachesize.Nodes), &api.Node{}, prefix, node.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Nodes), &api.Node{}, prefix, node.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &api.Node{} }, diff --git a/pkg/registry/node/etcd/etcd_test.go b/pkg/registry/node/etcd/etcd_test.go index 8199e690bd..7dae78b479 100644 --- a/pkg/registry/node/etcd/etcd_test.go +++ b/pkg/registry/node/etcd/etcd_test.go @@ -39,7 +39,8 @@ func (fakeConnectionInfoGetter) GetConnectionInfo(ctx api.Context, nodeName stri func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, "") - storage := NewStorage(etcdStorage, generic.UndecoratedStorage, fakeConnectionInfoGetter{}, nil) + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + storage := NewStorage(restOptions, fakeConnectionInfoGetter{}, nil) return storage.Node, server } diff --git a/pkg/registry/persistentvolume/etcd/etcd.go b/pkg/registry/persistentvolume/etcd/etcd.go index 60136ddefa..d0a51c4d7f 100644 --- a/pkg/registry/persistentvolume/etcd/etcd.go +++ b/pkg/registry/persistentvolume/etcd/etcd.go @@ -25,7 +25,6 @@ import ( etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" "k8s.io/kubernetes/pkg/registry/persistentvolume" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) type REST struct { @@ -33,12 +32,12 @@ type REST struct { } // NewREST returns a RESTStorage object that will work against persistent volumes. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) { +func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) { prefix := "/persistentvolumes" newListFunc := func() runtime.Object { return &api.PersistentVolumeList{} } - storageInterface := storageDecorator( - s, cachesize.GetWatchCacheSizeByResource(cachesize.PersistentVolumes), &api.PersistentVolume{}, prefix, persistentvolume.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.PersistentVolumes), &api.PersistentVolume{}, prefix, persistentvolume.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &api.PersistentVolume{} }, diff --git a/pkg/registry/persistentvolume/etcd/etcd_test.go b/pkg/registry/persistentvolume/etcd/etcd_test.go index 3a498ca830..f0ef32418d 100644 --- a/pkg/registry/persistentvolume/etcd/etcd_test.go +++ b/pkg/registry/persistentvolume/etcd/etcd_test.go @@ -33,7 +33,8 @@ import ( func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, "") - persistentVolumeStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + persistentVolumeStorage, statusStorage := NewREST(restOptions) return persistentVolumeStorage, statusStorage, server } diff --git a/pkg/registry/persistentvolumeclaim/etcd/etcd.go b/pkg/registry/persistentvolumeclaim/etcd/etcd.go index 1a245f6e9d..e218a9bee8 100644 --- a/pkg/registry/persistentvolumeclaim/etcd/etcd.go +++ b/pkg/registry/persistentvolumeclaim/etcd/etcd.go @@ -25,7 +25,6 @@ import ( etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" "k8s.io/kubernetes/pkg/registry/persistentvolumeclaim" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) type REST struct { @@ -33,12 +32,12 @@ type REST struct { } // NewREST returns a RESTStorage object that will work against persistent volume claims. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) { +func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) { prefix := "/persistentvolumeclaims" newListFunc := func() runtime.Object { return &api.PersistentVolumeClaimList{} } - storageInterface := storageDecorator( - s, cachesize.GetWatchCacheSizeByResource(cachesize.PersistentVolumeClaims), &api.PersistentVolumeClaim{}, prefix, persistentvolumeclaim.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.PersistentVolumeClaims), &api.PersistentVolumeClaim{}, prefix, persistentvolumeclaim.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &api.PersistentVolumeClaim{} }, diff --git a/pkg/registry/persistentvolumeclaim/etcd/etcd_test.go b/pkg/registry/persistentvolumeclaim/etcd/etcd_test.go index 7ae360baec..499fa2951e 100644 --- a/pkg/registry/persistentvolumeclaim/etcd/etcd_test.go +++ b/pkg/registry/persistentvolumeclaim/etcd/etcd_test.go @@ -33,7 +33,8 @@ import ( func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, "") - persistentVolumeClaimStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + persistentVolumeClaimStorage, statusStorage := NewREST(restOptions) return persistentVolumeClaimStorage, statusStorage, server } diff --git a/pkg/registry/pod/etcd/etcd.go b/pkg/registry/pod/etcd/etcd.go index f5769cea68..5db0667fc3 100644 --- a/pkg/registry/pod/etcd/etcd.go +++ b/pkg/registry/pod/etcd/etcd.go @@ -58,17 +58,12 @@ type REST struct { } // NewStorage returns a RESTStorage object that will work against pods. -func NewStorage( - s storage.Interface, - storageDecorator generic.StorageDecorator, - k client.ConnectionInfoGetter, - proxyTransport http.RoundTripper, -) PodStorage { +func NewStorage(opts generic.RESTOptions, k client.ConnectionInfoGetter, proxyTransport http.RoundTripper) PodStorage { prefix := "/pods" newListFunc := func() runtime.Object { return &api.PodList{} } - storageInterface := storageDecorator( - s, cachesize.GetWatchCacheSizeByResource(cachesize.Pods), &api.Pod{}, prefix, pod.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Pods), &api.Pod{}, prefix, pod.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &api.Pod{} }, diff --git a/pkg/registry/pod/etcd/etcd_test.go b/pkg/registry/pod/etcd/etcd_test.go index 3e5e6e23c2..6ccb245361 100644 --- a/pkg/registry/pod/etcd/etcd_test.go +++ b/pkg/registry/pod/etcd/etcd_test.go @@ -37,7 +37,8 @@ import ( func newStorage(t *testing.T) (*REST, *BindingREST, *StatusREST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, "") - storage := NewStorage(etcdStorage, generic.UndecoratedStorage, nil, nil) + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + storage := NewStorage(restOptions, nil, nil) return storage.Pod, storage.Binding, storage.Status, server } diff --git a/pkg/registry/podsecuritypolicy/etcd/etcd.go b/pkg/registry/podsecuritypolicy/etcd/etcd.go index 40b181da63..644a10f618 100644 --- a/pkg/registry/podsecuritypolicy/etcd/etcd.go +++ b/pkg/registry/podsecuritypolicy/etcd/etcd.go @@ -25,7 +25,6 @@ import ( etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" "k8s.io/kubernetes/pkg/registry/podsecuritypolicy" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) // REST implements a RESTStorage for PodSecurityPolicies against etcd. @@ -36,10 +35,10 @@ type REST struct { const Prefix = "/podsecuritypolicies" // NewREST returns a RESTStorage object that will work against PodSecurityPolicy objects. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) *REST { +func NewREST(opts generic.RESTOptions) *REST { newListFunc := func() runtime.Object { return &extensions.PodSecurityPolicyList{} } - storageInterface := storageDecorator( - s, 100, &extensions.PodSecurityPolicy{}, Prefix, podsecuritypolicy.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, 100, &extensions.PodSecurityPolicy{}, Prefix, podsecuritypolicy.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &extensions.PodSecurityPolicy{} }, diff --git a/pkg/registry/podsecuritypolicy/etcd/etcd_test.go b/pkg/registry/podsecuritypolicy/etcd/etcd_test.go index 4fd96066e5..9e1071045d 100644 --- a/pkg/registry/podsecuritypolicy/etcd/etcd_test.go +++ b/pkg/registry/podsecuritypolicy/etcd/etcd_test.go @@ -33,7 +33,8 @@ import ( func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions") - return NewREST(etcdStorage, generic.UndecoratedStorage), server + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + return NewREST(restOptions), server } func validNewPodSecurityPolicy() *extensions.PodSecurityPolicy { diff --git a/pkg/registry/podtemplate/etcd/etcd.go b/pkg/registry/podtemplate/etcd/etcd.go index 17d2718a60..73a2377327 100644 --- a/pkg/registry/podtemplate/etcd/etcd.go +++ b/pkg/registry/podtemplate/etcd/etcd.go @@ -25,7 +25,6 @@ import ( etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" "k8s.io/kubernetes/pkg/registry/podtemplate" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) type REST struct { @@ -33,12 +32,12 @@ type REST struct { } // NewREST returns a RESTStorage object that will work against pod templates. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) *REST { +func NewREST(opts generic.RESTOptions) *REST { prefix := "/podtemplates" newListFunc := func() runtime.Object { return &api.PodTemplateList{} } - storageInterface := storageDecorator( - s, cachesize.GetWatchCacheSizeByResource(cachesize.PodTemplates), &api.PodTemplate{}, prefix, podtemplate.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.PodTemplates), &api.PodTemplate{}, prefix, podtemplate.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &api.PodTemplate{} }, diff --git a/pkg/registry/podtemplate/etcd/etcd_test.go b/pkg/registry/podtemplate/etcd/etcd_test.go index 17ee998b19..c6c10dd18b 100644 --- a/pkg/registry/podtemplate/etcd/etcd_test.go +++ b/pkg/registry/podtemplate/etcd/etcd_test.go @@ -30,7 +30,8 @@ import ( func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, "") - return NewREST(etcdStorage, generic.UndecoratedStorage), server + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + return NewREST(restOptions), server } func validNewPodTemplate(name string) *api.PodTemplate { diff --git a/pkg/registry/replicaset/etcd/etcd.go b/pkg/registry/replicaset/etcd/etcd.go index f6d606be2a..ce0f4f4f46 100644 --- a/pkg/registry/replicaset/etcd/etcd.go +++ b/pkg/registry/replicaset/etcd/etcd.go @@ -28,7 +28,6 @@ import ( etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" "k8s.io/kubernetes/pkg/registry/replicaset" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) // ReplicaSetStorage includes dummy storage for ReplicaSets and for Scale subresource. @@ -37,8 +36,8 @@ type ReplicaSetStorage struct { Status *StatusREST } -func NewStorage(s storage.Interface, storageDecorator generic.StorageDecorator) ReplicaSetStorage { - replicaSetRest, replicaSetStatusRest := NewREST(s, storageDecorator) +func NewStorage(opts generic.RESTOptions) ReplicaSetStorage { + replicaSetRest, replicaSetStatusRest := NewREST(opts) return ReplicaSetStorage{ ReplicaSet: replicaSetRest, @@ -51,12 +50,12 @@ type REST struct { } // NewREST returns a RESTStorage object that will work against ReplicaSet. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) { +func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) { prefix := "/replicasets" newListFunc := func() runtime.Object { return &extensions.ReplicaSetList{} } - storageInterface := storageDecorator( - s, cachesize.GetWatchCacheSizeByResource(cachesize.Replicasets), &extensions.ReplicaSet{}, prefix, replicaset.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Replicasets), &extensions.ReplicaSet{}, prefix, replicaset.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &extensions.ReplicaSet{} }, diff --git a/pkg/registry/replicaset/etcd/etcd_test.go b/pkg/registry/replicaset/etcd/etcd_test.go index f765459751..a6c2836a2e 100644 --- a/pkg/registry/replicaset/etcd/etcd_test.go +++ b/pkg/registry/replicaset/etcd/etcd_test.go @@ -32,7 +32,8 @@ import ( func newStorage(t *testing.T) (*ReplicaSetStorage, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions") - replicaSetStorage := NewStorage(etcdStorage, generic.UndecoratedStorage) + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + replicaSetStorage := NewStorage(restOptions) return &replicaSetStorage, server } diff --git a/pkg/registry/resourcequota/etcd/etcd.go b/pkg/registry/resourcequota/etcd/etcd.go index b28b70c4cb..f6421451e7 100644 --- a/pkg/registry/resourcequota/etcd/etcd.go +++ b/pkg/registry/resourcequota/etcd/etcd.go @@ -25,7 +25,6 @@ import ( etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" "k8s.io/kubernetes/pkg/registry/resourcequota" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) type REST struct { @@ -33,12 +32,12 @@ type REST struct { } // NewREST returns a RESTStorage object that will work against resource quotas. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) { +func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) { prefix := "/resourcequotas" newListFunc := func() runtime.Object { return &api.ResourceQuotaList{} } - storageInterface := storageDecorator( - s, cachesize.GetWatchCacheSizeByResource(cachesize.ResourceQuotas), &api.ResourceQuota{}, prefix, resourcequota.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.ResourceQuotas), &api.ResourceQuota{}, prefix, resourcequota.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &api.ResourceQuota{} }, diff --git a/pkg/registry/resourcequota/etcd/etcd_test.go b/pkg/registry/resourcequota/etcd/etcd_test.go index d93924acf5..1423151a71 100644 --- a/pkg/registry/resourcequota/etcd/etcd_test.go +++ b/pkg/registry/resourcequota/etcd/etcd_test.go @@ -32,7 +32,8 @@ import ( func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, "") - resourceQuotaStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + resourceQuotaStorage, statusStorage := NewREST(restOptions) return resourceQuotaStorage, statusStorage, server } diff --git a/pkg/registry/secret/etcd/etcd.go b/pkg/registry/secret/etcd/etcd.go index fc8018f3f2..d8fc89b1df 100644 --- a/pkg/registry/secret/etcd/etcd.go +++ b/pkg/registry/secret/etcd/etcd.go @@ -25,7 +25,6 @@ import ( etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" "k8s.io/kubernetes/pkg/registry/secret" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) type REST struct { @@ -33,12 +32,12 @@ type REST struct { } // NewREST returns a RESTStorage object that will work against secrets. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) *REST { +func NewREST(opts generic.RESTOptions) *REST { prefix := "/secrets" newListFunc := func() runtime.Object { return &api.SecretList{} } - storageInterface := storageDecorator( - s, cachesize.GetWatchCacheSizeByResource(cachesize.Secrets), &api.Secret{}, prefix, secret.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Secrets), &api.Secret{}, prefix, secret.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &api.Secret{} }, diff --git a/pkg/registry/secret/etcd/etcd_test.go b/pkg/registry/secret/etcd/etcd_test.go index 35fd503e8d..626e6434ac 100644 --- a/pkg/registry/secret/etcd/etcd_test.go +++ b/pkg/registry/secret/etcd/etcd_test.go @@ -30,7 +30,8 @@ import ( func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, "") - return NewREST(etcdStorage, generic.UndecoratedStorage), server + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + return NewREST(restOptions), server } func validNewSecret(name string) *api.Secret { diff --git a/pkg/registry/service/etcd/etcd.go b/pkg/registry/service/etcd/etcd.go index 1941779ee3..9aa3ddfdcd 100644 --- a/pkg/registry/service/etcd/etcd.go +++ b/pkg/registry/service/etcd/etcd.go @@ -25,7 +25,6 @@ import ( etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" "k8s.io/kubernetes/pkg/registry/service" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) type REST struct { @@ -33,12 +32,12 @@ type REST struct { } // NewREST returns a RESTStorage object that will work against services. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) { +func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) { prefix := "/services/specs" newListFunc := func() runtime.Object { return &api.ServiceList{} } - storageInterface := storageDecorator( - s, cachesize.GetWatchCacheSizeByResource(cachesize.Services), &api.Service{}, prefix, service.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Services), &api.Service{}, prefix, service.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &api.Service{} }, diff --git a/pkg/registry/service/etcd/etcd_test.go b/pkg/registry/service/etcd/etcd_test.go index ee03203457..6a78d29b1d 100644 --- a/pkg/registry/service/etcd/etcd_test.go +++ b/pkg/registry/service/etcd/etcd_test.go @@ -31,7 +31,8 @@ import ( func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, "") - serviceStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + serviceStorage, statusStorage := NewREST(restOptions) return serviceStorage, statusStorage, server } diff --git a/pkg/registry/serviceaccount/etcd/etcd.go b/pkg/registry/serviceaccount/etcd/etcd.go index 14f71a2db5..d41d7773fd 100644 --- a/pkg/registry/serviceaccount/etcd/etcd.go +++ b/pkg/registry/serviceaccount/etcd/etcd.go @@ -25,7 +25,6 @@ import ( etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" "k8s.io/kubernetes/pkg/registry/serviceaccount" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) type REST struct { @@ -33,12 +32,12 @@ type REST struct { } // NewREST returns a RESTStorage object that will work against service accounts. -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) *REST { +func NewREST(opts generic.RESTOptions) *REST { prefix := "/serviceaccounts" newListFunc := func() runtime.Object { return &api.ServiceAccountList{} } - storageInterface := storageDecorator( - s, cachesize.GetWatchCacheSizeByResource(cachesize.ServiceAccounts), &api.ServiceAccount{}, prefix, serviceaccount.Strategy, newListFunc) + storageInterface := opts.Decorator( + opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.ServiceAccounts), &api.ServiceAccount{}, prefix, serviceaccount.Strategy, newListFunc) store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &api.ServiceAccount{} }, diff --git a/pkg/registry/serviceaccount/etcd/etcd_test.go b/pkg/registry/serviceaccount/etcd/etcd_test.go index 2cf2aaadca..8704ae8db7 100644 --- a/pkg/registry/serviceaccount/etcd/etcd_test.go +++ b/pkg/registry/serviceaccount/etcd/etcd_test.go @@ -30,7 +30,8 @@ import ( func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, "") - return NewREST(etcdStorage, generic.UndecoratedStorage), server + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + return NewREST(restOptions), server } func validNewServiceAccount(name string) *api.ServiceAccount { diff --git a/pkg/registry/thirdpartyresource/etcd/etcd.go b/pkg/registry/thirdpartyresource/etcd/etcd.go index db282c6cbb..0a62486558 100644 --- a/pkg/registry/thirdpartyresource/etcd/etcd.go +++ b/pkg/registry/thirdpartyresource/etcd/etcd.go @@ -25,7 +25,6 @@ import ( etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" "k8s.io/kubernetes/pkg/registry/thirdpartyresource" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) // REST implements a RESTStorage for ThirdPartyResources against etcd @@ -34,11 +33,11 @@ type REST struct { } // NewREST returns a registry which will store ThirdPartyResource in the given helper -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) *REST { +func NewREST(opts generic.RESTOptions) *REST { prefix := "/thirdpartyresources" // We explicitly do NOT do any decoration here yet. - storageInterface := s + storageInterface := opts.Storage store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &extensions.ThirdPartyResource{} }, diff --git a/pkg/registry/thirdpartyresource/etcd/etcd_test.go b/pkg/registry/thirdpartyresource/etcd/etcd_test.go index 0957e189a5..dc9cad3960 100644 --- a/pkg/registry/thirdpartyresource/etcd/etcd_test.go +++ b/pkg/registry/thirdpartyresource/etcd/etcd_test.go @@ -33,7 +33,8 @@ import ( func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, extensions.GroupName) - return NewREST(etcdStorage, generic.UndecoratedStorage), server + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + return NewREST(restOptions), server } func validNewThirdPartyResource(name string) *extensions.ThirdPartyResource { diff --git a/pkg/registry/thirdpartyresourcedata/etcd/etcd.go b/pkg/registry/thirdpartyresourcedata/etcd/etcd.go index 98e7662a9f..d0689faec7 100644 --- a/pkg/registry/thirdpartyresourcedata/etcd/etcd.go +++ b/pkg/registry/thirdpartyresourcedata/etcd/etcd.go @@ -27,7 +27,6 @@ import ( etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd" "k8s.io/kubernetes/pkg/registry/thirdpartyresourcedata" "k8s.io/kubernetes/pkg/runtime" - "k8s.io/kubernetes/pkg/storage" ) // REST implements a RESTStorage for ThirdPartyResourceDatas against etcd @@ -37,11 +36,11 @@ type REST struct { } // NewREST returns a registry which will store ThirdPartyResourceData in the given helper -func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator, group, kind string) *REST { +func NewREST(opts generic.RESTOptions, group, kind string) *REST { prefix := "/ThirdPartyResourceData/" + group + "/" + strings.ToLower(kind) + "s" // We explicitly do NOT do any decoration here yet. - storageInterface := s + storageInterface := opts.Storage store := &etcdgeneric.Etcd{ NewFunc: func() runtime.Object { return &extensions.ThirdPartyResourceData{} }, diff --git a/pkg/registry/thirdpartyresourcedata/etcd/etcd_test.go b/pkg/registry/thirdpartyresourcedata/etcd/etcd_test.go index 1aa827cd76..4f70e6aa63 100644 --- a/pkg/registry/thirdpartyresourcedata/etcd/etcd_test.go +++ b/pkg/registry/thirdpartyresourcedata/etcd/etcd_test.go @@ -33,7 +33,8 @@ import ( func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { etcdStorage, server := registrytest.NewEtcdStorage(t, extensions.GroupName) - return NewREST(etcdStorage, generic.UndecoratedStorage, "foo", "bar"), server + restOptions := generic.RESTOptions{etcdStorage, generic.UndecoratedStorage} + return NewREST(restOptions, "foo", "bar"), server } func validNewThirdPartyResourceData(name string) *extensions.ThirdPartyResourceData {