github
/
k3s
mirror of https://github.com/k3s-io/k3s
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Introduce RESTOptions to configure per-resource storage

pull/6/head
Wojciech Tyczynski 2016-02-22 10:15:22 +01:00
parent c533ae4dd0
commit 4eadc5e97b
53 changed files with 201 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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})),
)
}

83
pkg/master/master.go
View File

@ -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
}

7
pkg/registry/configmap/etcd/etcd.go
View File

@ -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 {

3
pkg/registry/configmap/etcd/etcd_test.go
View File

@ -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 {

7
pkg/registry/controller/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/controller/etcd/etcd_test.go
View File

@ -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
}

7
pkg/registry/daemonset/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/daemonset/etcd/etcd_test.go
View File

@ -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
}

10
pkg/registry/deployment/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/deployment/etcd/etcd_test.go
View File

@ -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
}

7
pkg/registry/endpoint/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/endpoint/etcd/etcd_test.go
View File

@ -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 {

5
pkg/registry/event/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/event/etcd/etcd_test.go
View File

@ -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 {

5
pkg/registry/experimental/controller/etcd/etcd.go
View File

@ -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{

3
pkg/registry/experimental/controller/etcd/etcd_test.go
View File

@ -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{

27
pkg/registry/generic/options.go Normal file
View File

@ -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
}

7
pkg/registry/horizontalpodautoscaler/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/horizontalpodautoscaler/etcd/etcd_test.go
View File

@ -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
}

7
pkg/registry/ingress/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/ingress/etcd/etcd_test.go
View File

@ -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
}

7
pkg/registry/job/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/job/etcd/etcd_test.go
View File

@ -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
}

7
pkg/registry/limitrange/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/limitrange/etcd/etcd_test.go
View File

@ -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 {

7
pkg/registry/namespace/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/namespace/etcd/etcd_test.go
View File

@ -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
}

7
pkg/registry/node/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/node/etcd/etcd_test.go
View File

@ -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
}

7
pkg/registry/persistentvolume/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/persistentvolume/etcd/etcd_test.go
View File

@ -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
}

7
pkg/registry/persistentvolumeclaim/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/persistentvolumeclaim/etcd/etcd_test.go
View File

@ -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
}

11
pkg/registry/pod/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/pod/etcd/etcd_test.go
View File

@ -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
}

7
pkg/registry/podsecuritypolicy/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/podsecuritypolicy/etcd/etcd_test.go
View File

@ -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 {

7
pkg/registry/podtemplate/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/podtemplate/etcd/etcd_test.go
View File

@ -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 {

11
pkg/registry/replicaset/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/replicaset/etcd/etcd_test.go
View File

@ -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
}

7
pkg/registry/resourcequota/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/resourcequota/etcd/etcd_test.go
View File

@ -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
}

7
pkg/registry/secret/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/secret/etcd/etcd_test.go
View File

@ -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 {

7
pkg/registry/service/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/service/etcd/etcd_test.go
View File

@ -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
}

7
pkg/registry/serviceaccount/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/serviceaccount/etcd/etcd_test.go
View File

@ -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 {

5
pkg/registry/thirdpartyresource/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/thirdpartyresource/etcd/etcd_test.go
View File

@ -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 {

5
pkg/registry/thirdpartyresourcedata/etcd/etcd.go
View File

@ -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{} },

3
pkg/registry/thirdpartyresourcedata/etcd/etcd_test.go
View File

@ -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 {