github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-30 15:05:27 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #16855 from wojtek-t/pass_versioner

Browse Source 
Auto commit by PR queue bot
This commit is contained in:
k8s-merge-robot 2015-11-13 02:59:13 -08:00
commit 3550df30ba
49 changed files with 218 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -19,6 +19,7 @@ package serviceaccount
import (
"k8s.io/kubernetes/pkg/api"
client "k8s.io/kubernetes/pkg/client/unversioned"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/secret"
secretetcd "k8s.io/kubernetes/pkg/registry/secret/etcd"
"k8s.io/kubernetes/pkg/registry/serviceaccount"
@ -75,7 +76,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) ServiceAccountTokenGetter {
return NewGetterFromRegistries(
serviceaccount.NewRegistry(serviceaccountetcd.NewREST(s, storage.NoDecoration)),
secret.NewRegistry(secretetcd.NewREST(s, storage.NoDecoration)),
serviceaccount.NewRegistry(serviceaccountetcd.NewREST(s, generic.UndecoratedStorage)),
secret.NewRegistry(secretetcd.NewREST(s, generic.UndecoratedStorage)),
)
}

56
pkg/master/master.go
View File

@ -51,6 +51,8 @@ import (
endpointsetcd "k8s.io/kubernetes/pkg/registry/endpoint/etcd"
eventetcd "k8s.io/kubernetes/pkg/registry/event/etcd"
expcontrolleretcd "k8s.io/kubernetes/pkg/registry/experimental/controller/etcd"
"k8s.io/kubernetes/pkg/registry/generic"
genericetcd "k8s.io/kubernetes/pkg/registry/generic/etcd"
ingressetcd "k8s.io/kubernetes/pkg/registry/ingress/etcd"
jobetcd "k8s.io/kubernetes/pkg/registry/job/etcd"
limitrangeetcd "k8s.io/kubernetes/pkg/registry/limitrange/etcd"
@ -268,11 +270,11 @@ type Config struct {
KubernetesServiceNodePort int
}
func (c *Config) storageFactory() storage.StorageFactory {
func (c *Config) storageDecorator() generic.StorageDecorator {
if c.EnableWatchCache {
return storage.NewCacher
return genericetcd.StorageWithCacher
}
return storage.NoDecoration
return generic.UndecoratedStorage
}
type InstallSSHKey func(user string, data []byte) error
@ -543,31 +545,31 @@ func (m *Master) init(c *Config) {
healthzChecks := []healthz.HealthzChecker{}
storageFactory := c.storageFactory()
storageDecorator := c.storageDecorator()
dbClient := func(resource string) storage.Interface { return c.StorageDestinations.get("", resource) }
podStorage := podetcd.NewStorage(dbClient("pods"), storageFactory, c.KubeletClient, m.proxyTransport)
podStorage := podetcd.NewStorage(dbClient("pods"), storageDecorator, c.KubeletClient, m.proxyTransport)
podTemplateStorage := podtemplateetcd.NewREST(dbClient("podTemplates"), storageFactory)
podTemplateStorage := podtemplateetcd.NewREST(dbClient("podTemplates"), storageDecorator)
eventStorage := eventetcd.NewREST(dbClient("events"), storageFactory, uint64(c.EventTTL.Seconds()))
limitRangeStorage := limitrangeetcd.NewREST(dbClient("limitRanges"), storageFactory)
eventStorage := eventetcd.NewREST(dbClient("events"), storageDecorator, uint64(c.EventTTL.Seconds()))
limitRangeStorage := limitrangeetcd.NewREST(dbClient("limitRanges"), storageDecorator)
resourceQuotaStorage, resourceQuotaStatusStorage := resourcequotaetcd.NewREST(dbClient("resourceQuotas"), storageFactory)
secretStorage := secretetcd.NewREST(dbClient("secrets"), storageFactory)
serviceAccountStorage := serviceaccountetcd.NewREST(dbClient("serviceAccounts"), storageFactory)
persistentVolumeStorage, persistentVolumeStatusStorage := pvetcd.NewREST(dbClient("persistentVolumes"), storageFactory)
persistentVolumeClaimStorage, persistentVolumeClaimStatusStorage := pvcetcd.NewREST(dbClient("persistentVolumeClaims"), storageFactory)
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)
namespaceStorage, namespaceStatusStorage, namespaceFinalizeStorage := namespaceetcd.NewREST(dbClient("namespaces"), storageFactory)
namespaceStorage, namespaceStatusStorage, namespaceFinalizeStorage := namespaceetcd.NewREST(dbClient("namespaces"), storageDecorator)
m.namespaceRegistry = namespace.NewRegistry(namespaceStorage)
endpointsStorage := endpointsetcd.NewREST(dbClient("endpoints"), storageFactory)
endpointsStorage := endpointsetcd.NewREST(dbClient("endpoints"), storageDecorator)
m.endpointRegistry = endpoint.NewRegistry(endpointsStorage)
nodeStorage, nodeStatusStorage := nodeetcd.NewREST(dbClient("nodes"), storageFactory, c.KubeletClient, m.proxyTransport)
nodeStorage, nodeStatusStorage := nodeetcd.NewREST(dbClient("nodes"), storageDecorator, c.KubeletClient, m.proxyTransport)
m.nodeRegistry = node.NewRegistry(nodeStorage)
serviceStorage := serviceetcd.NewREST(dbClient("services"), storageFactory)
serviceStorage := serviceetcd.NewREST(dbClient("services"), storageDecorator)
m.serviceRegistry = service.NewRegistry(serviceStorage)
var serviceClusterIPRegistry service.RangeRegistry
@ -588,7 +590,7 @@ func (m *Master) init(c *Config) {
})
m.serviceNodePortAllocator = serviceNodePortRegistry
controllerStorage, controllerStatusStorage := controlleretcd.NewREST(dbClient("replicationControllers"), storageFactory)
controllerStorage, controllerStatusStorage := controlleretcd.NewREST(dbClient("replicationControllers"), storageDecorator)
// TODO: Factor out the core API registration
m.storage = map[string]rest.Storage{
@ -1008,7 +1010,7 @@ func (m *Master) InstallThirdPartyResource(rsrc *expapi.ThirdPartyResource) erro
}
func (m *Master) thirdpartyapi(group, kind, version string) *apiserver.APIGroupVersion {
resourceStorage := thirdpartyresourcedataetcd.NewREST(m.thirdPartyStorage, storage.NoDecoration, group, kind)
resourceStorage := thirdpartyresourcedataetcd.NewREST(m.thirdPartyStorage, generic.UndecoratedStorage, group, kind)
apiRoot := makeThirdPartyPath("")
@ -1050,22 +1052,22 @@ func (m *Master) experimental(c *Config) *apiserver.APIGroupVersion {
}
return enabled
}
storageFactory := c.storageFactory()
storageDecorator := c.storageDecorator()
dbClient := func(resource string) storage.Interface {
return c.StorageDestinations.get("extensions", resource)
}
storage := map[string]rest.Storage{}
if isEnabled("horizontalpodautoscalers") {
autoscalerStorage, autoscalerStatusStorage := horizontalpodautoscaleretcd.NewREST(dbClient("horizontalpodautoscalers"), storageFactory)
autoscalerStorage, autoscalerStatusStorage := horizontalpodautoscaleretcd.NewREST(dbClient("horizontalpodautoscalers"), storageDecorator)
storage["horizontalpodautoscalers"] = autoscalerStorage
storage["horizontalpodautoscalers/status"] = autoscalerStatusStorage
controllerStorage := expcontrolleretcd.NewStorage(c.StorageDestinations.get("", "replicationControllers"), storageFactory)
controllerStorage := expcontrolleretcd.NewStorage(c.StorageDestinations.get("", "replicationControllers"), storageDecorator)
storage["replicationcontrollers"] = controllerStorage.ReplicationController
storage["replicationcontrollers/scale"] = controllerStorage.Scale
}
if isEnabled("thirdpartyresources") {
thirdPartyResourceStorage := thirdpartyresourceetcd.NewREST(dbClient("thirdpartyresources"), storageFactory)
thirdPartyResourceStorage := thirdpartyresourceetcd.NewREST(dbClient("thirdpartyresources"), storageDecorator)
thirdPartyControl := ThirdPartyController{
master: m,
thirdPartyResourceRegistry: thirdPartyResourceStorage,
@ -1082,23 +1084,23 @@ func (m *Master) experimental(c *Config) *apiserver.APIGroupVersion {
}
if isEnabled("daemonsets") {
daemonSetStorage, daemonSetStatusStorage := daemonetcd.NewREST(dbClient("daemonsets"), storageFactory)
daemonSetStorage, daemonSetStatusStorage := daemonetcd.NewREST(dbClient("daemonsets"), storageDecorator)
storage["daemonsets"] = daemonSetStorage
storage["daemonsets/status"] = daemonSetStatusStorage
}
if isEnabled("deployments") {
deploymentStorage := deploymentetcd.NewStorage(dbClient("deployments"), storageFactory)
deploymentStorage := deploymentetcd.NewStorage(dbClient("deployments"), storageDecorator)
storage["deployments"] = deploymentStorage.Deployment
storage["deployments/status"] = deploymentStorage.Status
storage["deployments/scale"] = deploymentStorage.Scale
}
if isEnabled("jobs") {
jobStorage, jobStatusStorage := jobetcd.NewREST(dbClient("jobs"), storageFactory)
jobStorage, jobStatusStorage := jobetcd.NewREST(dbClient("jobs"), storageDecorator)
storage["jobs"] = jobStorage
storage["jobs/status"] = jobStatusStorage
}
if isEnabled("ingresses") {
ingressStorage, ingressStatusStorage := ingressetcd.NewREST(dbClient("ingresses"), storageFactory)
ingressStorage, ingressStatusStorage := ingressetcd.NewREST(dbClient("ingresses"), storageDecorator)
storage["ingresses"] = ingressStorage
storage["ingresses/status"] = ingressStatusStorage
}

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

@ -32,12 +32,12 @@ type REST struct {
}
// NewREST returns a RESTStorage object that will work against replication controllers.
func NewREST(s storage.Interface, storageFactory storage.StorageFactory) (*REST, *StatusREST) {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) {
prefix := "/controllers"
newListFunc := func() runtime.Object { return &api.ReplicationControllerList{} }
storageInterface := storageFactory(
s, 100, nil, &api.ReplicationController{}, prefix, true, newListFunc)
storageInterface := storageDecorator(
s, 100, &api.ReplicationController{}, prefix, true, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.ReplicationController{} },

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

@ -22,15 +22,15 @@ import (
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/tools"
)
func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
controllerStorage, statusStorage := NewREST(etcdStorage, storage.NoDecoration)
controllerStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return controllerStorage, statusStorage, fakeClient
}

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

@ -34,12 +34,12 @@ type REST struct {
}
// NewREST returns a RESTStorage object that will work against DaemonSets.
func NewREST(s storage.Interface, storageFactory storage.StorageFactory) (*REST, *StatusREST) {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) {
prefix := "/daemonsets"
newListFunc := func() runtime.Object { return &extensions.DaemonSetList{} }
storageInterface := storageFactory(
s, 100, nil, &extensions.DaemonSet{}, prefix, false, newListFunc)
storageInterface := storageDecorator(
s, 100, &extensions.DaemonSet{}, prefix, false, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &extensions.DaemonSet{} },

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

@ -23,15 +23,15 @@ import (
"k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/tools"
)
func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
daemonSetStorage, statusStorage := NewREST(etcdStorage, storage.NoDecoration)
daemonSetStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return daemonSetStorage, statusStorage, fakeClient
}

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

@ -39,8 +39,8 @@ type DeploymentStorage struct {
Scale *ScaleREST
}
func NewStorage(s storage.Interface, storageFactory storage.StorageFactory) DeploymentStorage {
deploymentRest, deploymentStatusRest := NewREST(s, storageFactory)
func NewStorage(s storage.Interface, storageDecorator generic.StorageDecorator) DeploymentStorage {
deploymentRest, deploymentStatusRest := NewREST(s, storageDecorator)
deploymentRegistry := deployment.NewRegistry(deploymentRest)
return DeploymentStorage{
@ -55,12 +55,12 @@ type REST struct {
}
// NewREST returns a RESTStorage object that will work against deployments.
func NewREST(s storage.Interface, storageFactory storage.StorageFactory) (*REST, *StatusREST) {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) {
prefix := "/deployments"
newListFunc := func() runtime.Object { return &extensions.DeploymentList{} }
storageInterface := storageFactory(
s, 100, nil, &extensions.Deployment{}, prefix, false, newListFunc)
storageInterface := storageDecorator(
s, 100, &extensions.Deployment{}, prefix, false, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &extensions.Deployment{} },

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

@ -24,9 +24,9 @@ import (
"k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
"k8s.io/kubernetes/pkg/tools"
"k8s.io/kubernetes/pkg/util"
@ -34,7 +34,7 @@ import (
func newStorage(t *testing.T) (*DeploymentStorage, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
deploymentStorage := NewStorage(etcdStorage, storage.NoDecoration)
deploymentStorage := NewStorage(etcdStorage, generic.UndecoratedStorage)
return &deploymentStorage, fakeClient
}

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

@ -32,12 +32,12 @@ type REST struct {
}
// NewREST returns a RESTStorage object that will work against endpoints.
func NewREST(s storage.Interface, storageFactory storage.StorageFactory) *REST {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) *REST {
prefix := "/services/endpoints"
newListFunc := func() runtime.Object { return &api.EndpointsList{} }
storageInterface := storageFactory(
s, 1000, nil, &api.Endpoints{}, prefix, true, newListFunc)
storageInterface := storageDecorator(
s, 1000, &api.Endpoints{}, prefix, true, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.Endpoints{} },

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

@ -22,15 +22,15 @@ import (
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/tools"
)
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
return NewREST(etcdStorage, storage.NoDecoration), fakeClient
return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
}
func validNewEndpoints() *api.Endpoints {

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

@ -32,7 +32,7 @@ type REST struct {
}
// NewREST returns a RESTStorage object that will work against events.
func NewREST(s storage.Interface, storageFactory storage.StorageFactory, ttl uint64) *REST {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator, ttl uint64) *REST {
prefix := "/events"
// We explicitly do NOT do any decoration here - switching on Cacher

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

@ -20,9 +20,9 @@ import (
"testing"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/tools"
)
@ -31,7 +31,7 @@ var testTTL uint64 = 60
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
fakeClient.HideExpires = true
return NewREST(etcdStorage, storage.NoDecoration, testTTL), fakeClient
return NewREST(etcdStorage, generic.UndecoratedStorage, testTTL), fakeClient
}
func validNewEvent(namespace string) *api.Event {

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

@ -27,6 +27,7 @@ import (
"k8s.io/kubernetes/pkg/registry/controller"
"k8s.io/kubernetes/pkg/registry/controller/etcd"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/apis/extensions"
)
@ -37,9 +38,9 @@ type ContainerStorage struct {
Scale *ScaleREST
}
func NewStorage(s storage.Interface, storageFactory storage.StorageFactory) ContainerStorage {
func NewStorage(s storage.Interface, storageDecorator generic.StorageDecorator) ContainerStorage {
// scale does not set status, only updates spec so we ignore the status
controllerREST, _ := etcd.NewREST(s, storageFactory)
controllerREST, _ := etcd.NewREST(s, storageDecorator)
rcRegistry := controller.NewRegistry(controllerREST)
return ContainerStorage{

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

@ -22,9 +22,9 @@ import (
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
"k8s.io/kubernetes/pkg/tools"
"k8s.io/kubernetes/pkg/util"
@ -32,7 +32,7 @@ import (
func newStorage(t *testing.T) (*ScaleREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
return NewStorage(etcdStorage, storage.NoDecoration).Scale, fakeClient
return NewStorage(etcdStorage, generic.UndecoratedStorage).Scale, fakeClient
}
var validPodTemplate = api.PodTemplate{

36
pkg/registry/generic/etcd/storage_factory.go Normal file
View File

@ -0,0 +1,36 @@
/*
Copyright 2015 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 etcd
import (
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
etcdstorage "k8s.io/kubernetes/pkg/storage/etcd"
)
// Creates a cacher on top of the given 'storageInterface'.
func StorageWithCacher(
storageInterface storage.Interface,
capacity int,
objectType runtime.Object,
resourcePrefix string,
namespaceScoped bool,
newListFunc func() runtime.Object) storage.Interface {
return storage.NewCacher(
storageInterface, capacity, etcdstorage.APIObjectVersioner{},
objectType, resourcePrefix, namespaceScoped, newListFunc)
}

43
pkg/registry/generic/storage_decorator.go Normal file
View File

@ -0,0 +1,43 @@
/*
Copyright 2015 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 (
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
)
// StorageDecorator is a function signature for producing
// a storage.Interface from given parameters.
type StorageDecorator func(
storageInterface storage.Interface,
capacity int,
objectType runtime.Object,
resourcePrefix string,
namespaceScoped bool,
newListFunc func() runtime.Object) storage.Interface
// Returns given 'storageInterface' without any decoration.
func UndecoratedStorage(
storageInterface storage.Interface,
capacity int,
objectType runtime.Object,
resourcePrefix string,
namespaceScoped bool,
newListFunc func() runtime.Object) storage.Interface {
return storageInterface
}

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

@ -33,12 +33,12 @@ type REST struct {
}
// NewREST returns a RESTStorage object that will work against horizontal pod autoscalers.
func NewREST(s storage.Interface, storageFactory storage.StorageFactory) (*REST, *StatusREST) {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) {
prefix := "/horizontalpodautoscalers"
newListFunc := func() runtime.Object { return &extensions.HorizontalPodAutoscalerList{} }
storageInterface := storageFactory(
s, 100, nil, &extensions.HorizontalPodAutoscaler{}, prefix, false, newListFunc)
storageInterface := storageDecorator(
s, 100, &extensions.HorizontalPodAutoscaler{}, prefix, false, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &extensions.HorizontalPodAutoscaler{} },

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

@ -25,15 +25,15 @@ import (
_ "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/tools"
)
func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
horizontalPodAutoscalerStorage, statusStorage := NewREST(etcdStorage, storage.NoDecoration)
horizontalPodAutoscalerStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return horizontalPodAutoscalerStorage, statusStorage, fakeClient
}

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

@ -34,12 +34,12 @@ type REST struct {
}
// NewREST returns a RESTStorage object that will work against replication controllers.
func NewREST(s storage.Interface, storageFactory storage.StorageFactory) (*REST, *StatusREST) {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) {
prefix := "/ingress"
newListFunc := func() runtime.Object { return &extensions.IngressList{} }
storageInterface := storageFactory(
s, 100, nil, &extensions.Ingress{}, prefix, false, newListFunc)
storageInterface := storageDecorator(
s, 100, &extensions.Ingress{}, prefix, false, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &extensions.Ingress{} },

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

@ -23,16 +23,16 @@ import (
"k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/tools"
"k8s.io/kubernetes/pkg/util"
)
func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
ingressStorage, statusStorage := NewREST(etcdStorage, storage.NoDecoration)
ingressStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return ingressStorage, statusStorage, fakeClient
}

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

@ -34,12 +34,12 @@ type REST struct {
}
// NewREST returns a RESTStorage object that will work against Jobs.
func NewREST(s storage.Interface, storageFactory storage.StorageFactory) (*REST, *StatusREST) {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) {
prefix := "/jobs"
newListFunc := func() runtime.Object { return &extensions.JobList{} }
storageInterface := storageFactory(
s, 100, nil, &extensions.Job{}, prefix, false, newListFunc)
storageInterface := storageDecorator(
s, 100, &extensions.Job{}, prefix, false, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &extensions.Job{} },

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

@ -25,15 +25,15 @@ import (
_ "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/tools"
)
func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
jobStorage, statusStorage := NewREST(etcdStorage, storage.NoDecoration)
jobStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return jobStorage, statusStorage, fakeClient
}

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

@ -32,12 +32,12 @@ type REST struct {
}
// NewREST returns a RESTStorage object that will work against horizontal pod autoscalers.
func NewREST(s storage.Interface, storageFactory storage.StorageFactory) *REST {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) *REST {
prefix := "/limitranges"
newListFunc := func() runtime.Object { return &api.LimitRangeList{} }
storageInterface := storageFactory(
s, 100, nil, &api.LimitRange{}, prefix, true, newListFunc)
storageInterface := storageDecorator(
s, 100, &api.LimitRange{}, prefix, true, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.LimitRange{} },

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

@ -23,15 +23,15 @@ import (
"k8s.io/kubernetes/pkg/api/resource"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/tools"
)
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
return NewREST(etcdStorage, storage.NoDecoration), fakeClient
return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
}
func validNewLimitRange() *api.LimitRange {

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

@ -48,12 +48,12 @@ type FinalizeREST struct {
}
// NewREST returns a RESTStorage object that will work against namespaces.
func NewREST(s storage.Interface, storageFactory storage.StorageFactory) (*REST, *StatusREST, *FinalizeREST) {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST, *FinalizeREST) {
prefix := "/namespaces"
newListFunc := func() runtime.Object { return &api.NamespaceList{} }
storageInterface := storageFactory(
s, 100, nil, &api.Namespace{}, prefix, true, newListFunc)
storageInterface := storageDecorator(
s, 100, &api.Namespace{}, prefix, true, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.Namespace{} },

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

@ -24,16 +24,16 @@ import (
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
"k8s.io/kubernetes/pkg/tools"
)
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
namespaceStorage, _, _ := NewREST(etcdStorage, storage.NoDecoration)
namespaceStorage, _, _ := NewREST(etcdStorage, generic.UndecoratedStorage)
return namespaceStorage, fakeClient
}

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

@ -23,6 +23,7 @@ import (
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/rest"
client "k8s.io/kubernetes/pkg/client/unversioned"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/node"
"k8s.io/kubernetes/pkg/runtime"
@ -50,12 +51,12 @@ func (r *StatusREST) Update(ctx api.Context, obj runtime.Object) (runtime.Object
}
// NewREST returns a RESTStorage object that will work against nodes.
func NewREST(s storage.Interface, storageFactory storage.StorageFactory, connection client.ConnectionInfoGetter, proxyTransport http.RoundTripper) (*REST, *StatusREST) {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator, connection client.ConnectionInfoGetter, proxyTransport http.RoundTripper) (*REST, *StatusREST) {
prefix := "/minions"
newListFunc := func() runtime.Object { return &api.NodeList{} }
storageInterface := storageFactory(
s, 1000, nil, &api.Node{}, prefix, false, newListFunc)
storageInterface := storageDecorator(
s, 1000, &api.Node{}, prefix, false, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.Node{} },

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

@ -24,9 +24,9 @@ import (
"k8s.io/kubernetes/pkg/api/resource"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/tools"
)
@ -39,7 +39,7 @@ func (fakeConnectionInfoGetter) GetConnectionInfo(host string) (string, uint, ht
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
storage, _ := NewREST(etcdStorage, storage.NoDecoration, fakeConnectionInfoGetter{}, nil)
storage, _ := NewREST(etcdStorage, generic.UndecoratedStorage, fakeConnectionInfoGetter{}, nil)
return storage, fakeClient
}

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

@ -32,12 +32,12 @@ type REST struct {
}
// NewREST returns a RESTStorage object that will work against persistent volumes.
func NewREST(s storage.Interface, storageFactory storage.StorageFactory) (*REST, *StatusREST) {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) {
prefix := "/persistentvolumes"
newListFunc := func() runtime.Object { return &api.PersistentVolumeList{} }
storageInterface := storageFactory(
s, 100, nil, &api.PersistentVolume{}, prefix, true, newListFunc)
storageInterface := storageDecorator(
s, 100, &api.PersistentVolume{}, prefix, true, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.PersistentVolume{} },

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

@ -24,9 +24,9 @@ import (
"k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
"k8s.io/kubernetes/pkg/tools"
"k8s.io/kubernetes/pkg/util"
@ -34,7 +34,7 @@ import (
func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
persistentVolumeStorage, statusStorage := NewREST(etcdStorage, storage.NoDecoration)
persistentVolumeStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return persistentVolumeStorage, statusStorage, fakeClient
}

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

@ -32,12 +32,12 @@ type REST struct {
}
// NewREST returns a RESTStorage object that will work against persistent volume claims.
func NewREST(s storage.Interface, storageFactory storage.StorageFactory) (*REST, *StatusREST) {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) {
prefix := "/persistentvolumeclaims"
newListFunc := func() runtime.Object { return &api.PersistentVolumeClaimList{} }
storageInterface := storageFactory(
s, 100, nil, &api.PersistentVolumeClaim{}, prefix, true, newListFunc)
storageInterface := storageDecorator(
s, 100, &api.PersistentVolumeClaim{}, prefix, true, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.PersistentVolumeClaim{} },

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

@ -24,9 +24,9 @@ import (
"k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
"k8s.io/kubernetes/pkg/tools"
"k8s.io/kubernetes/pkg/util"
@ -34,7 +34,7 @@ import (
func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
persistentVolumeClaimStorage, statusStorage := NewREST(etcdStorage, storage.NoDecoration)
persistentVolumeClaimStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return persistentVolumeClaimStorage, statusStorage, fakeClient
}

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

@ -57,12 +57,12 @@ type REST struct {
}
// NewStorage returns a RESTStorage object that will work against pods.
func NewStorage(s storage.Interface, storageFactory storage.StorageFactory, k client.ConnectionInfoGetter, proxyTransport http.RoundTripper) PodStorage {
func NewStorage(s storage.Interface, storageDecorator generic.StorageDecorator, k client.ConnectionInfoGetter, proxyTransport http.RoundTripper) PodStorage {
prefix := "/pods"
newListFunc := func() runtime.Object { return &api.PodList{} }
storageInterface := storageFactory(
s, 1000, nil, &api.Pod{}, prefix, true, newListFunc)
storageInterface := storageDecorator(
s, 1000, &api.Pod{}, prefix, true, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.Pod{} },

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

@ -28,10 +28,10 @@ import (
"k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/securitycontext"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
"k8s.io/kubernetes/pkg/tools"
"k8s.io/kubernetes/pkg/util"
@ -39,7 +39,7 @@ import (
func newStorage(t *testing.T) (*REST, *BindingREST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
storage := NewStorage(etcdStorage, storage.NoDecoration, nil, nil)
storage := NewStorage(etcdStorage, generic.UndecoratedStorage, nil, nil)
return storage.Pod, storage.Binding, storage.Status, fakeClient
}

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

@ -32,12 +32,12 @@ type REST struct {
}
// NewREST returns a RESTStorage object that will work against pod templates.
func NewREST(s storage.Interface, storageFactory storage.StorageFactory) *REST {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) *REST {
prefix := "/podtemplates"
newListFunc := func() runtime.Object { return &api.PodTemplateList{} }
storageInterface := storageFactory(
s, 100, nil, &api.PodTemplate{}, prefix, false, newListFunc)
storageInterface := storageDecorator(
s, 100, &api.PodTemplate{}, prefix, false, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.PodTemplate{} },

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

@ -22,15 +22,15 @@ import (
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/tools"
)
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
return NewREST(etcdStorage, storage.NoDecoration), fakeClient
return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
}
func validNewPodTemplate(name string) *api.PodTemplate {

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

@ -32,12 +32,12 @@ type REST struct {
}
// NewREST returns a RESTStorage object that will work against resource quotas.
func NewREST(s storage.Interface, storageFactory storage.StorageFactory) (*REST, *StatusREST) {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) {
prefix := "/resourcequotas"
newListFunc := func() runtime.Object { return &api.ResourceQuotaList{} }
storageInterface := storageFactory(
s, 100, nil, &api.ResourceQuota{}, prefix, true, newListFunc)
storageInterface := storageDecorator(
s, 100, &api.ResourceQuota{}, prefix, true, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.ResourceQuota{} },

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

@ -25,9 +25,9 @@ import (
"k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
"k8s.io/kubernetes/pkg/tools"
"k8s.io/kubernetes/pkg/util"
@ -35,7 +35,7 @@ import (
func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
resourceQuotaStorage, statusStorage := NewREST(etcdStorage, storage.NoDecoration)
resourceQuotaStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return resourceQuotaStorage, statusStorage, fakeClient
}

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

@ -32,12 +32,12 @@ type REST struct {
}
// NewREST returns a RESTStorage object that will work against secrets.
func NewREST(s storage.Interface, storageFactory storage.StorageFactory) *REST {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) *REST {
prefix := "/secrets"
newListFunc := func() runtime.Object { return &api.SecretList{} }
storageInterface := storageFactory(
s, 100, nil, &api.Secret{}, prefix, true, newListFunc)
storageInterface := storageDecorator(
s, 100, &api.Secret{}, prefix, true, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.Secret{} },

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

@ -22,15 +22,15 @@ import (
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/tools"
)
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
return NewREST(etcdStorage, storage.NoDecoration), fakeClient
return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
}
func validNewSecret(name string) *api.Secret {

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

@ -32,12 +32,12 @@ type REST struct {
}
// NewREST returns a RESTStorage object that will work against services.
func NewREST(s storage.Interface, storageFactory storage.StorageFactory) *REST {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) *REST {
prefix := "/services/specs"
newListFunc := func() runtime.Object { return &api.ServiceList{} }
storageInterface := storageFactory(
s, 100, nil, &api.Service{}, prefix, false, newListFunc)
storageInterface := storageDecorator(
s, 100, &api.Service{}, prefix, false, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.Service{} },

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

@ -22,16 +22,16 @@ import (
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/tools"
"k8s.io/kubernetes/pkg/util"
)
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
return NewREST(etcdStorage, storage.NoDecoration), fakeClient
return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
}
func validService() *api.Service {

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

@ -32,12 +32,12 @@ type REST struct {
}
// NewREST returns a RESTStorage object that will work against service accounts.
func NewREST(s storage.Interface, storageFactory storage.StorageFactory) *REST {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) *REST {
prefix := "/serviceaccounts"
newListFunc := func() runtime.Object { return &api.ServiceAccountList{} }
storageInterface := storageFactory(
s, 100, nil, &api.ServiceAccount{}, prefix, true, newListFunc)
storageInterface := storageDecorator(
s, 100, &api.ServiceAccount{}, prefix, true, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.ServiceAccount{} },

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

@ -22,15 +22,15 @@ import (
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/tools"
)
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "")
return NewREST(etcdStorage, storage.NoDecoration), fakeClient
return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
}
func validNewServiceAccount(name string) *api.ServiceAccount {

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

@ -34,7 +34,7 @@ type REST struct {
}
// NewREST returns a registry which will store ThirdPartyResource in the given helper
func NewREST(s storage.Interface, storageFactory storage.StorageFactory) *REST {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) *REST {
prefix := "/thirdpartyresources"
// We explicitly do NOT do any decoration here yet.

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

@ -25,15 +25,15 @@ import (
_ "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/tools"
)
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
return NewREST(etcdStorage, storage.NoDecoration), fakeClient
return NewREST(etcdStorage, generic.UndecoratedStorage), fakeClient
}
func validNewThirdPartyResource(name string) *extensions.ThirdPartyResource {

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

@ -36,7 +36,7 @@ type REST struct {
}
// NewREST returns a registry which will store ThirdPartyResourceData in the given helper
func NewREST(s storage.Interface, storageFactory storage.StorageFactory, group, kind string) *REST {
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator, group, kind string) *REST {
prefix := "/ThirdPartyResourceData/" + group + "/" + strings.ToLower(kind) + "s"
// We explicitly do NOT do any decoration here yet.

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

@ -25,15 +25,15 @@ import (
_ "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/registry/registrytest"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
"k8s.io/kubernetes/pkg/tools"
)
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
return NewREST(etcdStorage, storage.NoDecoration, "foo", "bar"), fakeClient
return NewREST(etcdStorage, generic.UndecoratedStorage, "foo", "bar"), fakeClient
}
func validNewThirdPartyResourceData(name string) *extensions.ThirdPartyResourceData {

22
pkg/storage/cacher.go
View File

@ -112,28 +112,6 @@ type Cacher struct {
ListFromCache bool
}
// StorageFactory is a function signature for producing
// a storage.Interface from given parameters.
type StorageFactory func(
storage Interface,
capacity int,
versioner Versioner,
objectType runtime.Object,
resourcePrefix string,
namespaceScoped bool,
newListFunc func() runtime.Object) Interface
func NoDecoration(
storage Interface,
capacity int,
versioner Versioner,
objectType runtime.Object,
resourcePrefix string,
namespaceScoped bool,
newListFunc func() runtime.Object) Interface {
return storage
}
// Create a new Cacher responsible from service WATCH and LIST requests from its
// internal cache and updating its cache in the background based on the given
// configuration.