Pass versioner to cacher.

pkg/controller/serviceaccount/tokengetter.go

@@ -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)),
+		serviceaccount.NewRegistry(serviceaccountetcd.NewREST(s, generic.UndecoratedStorage)),
-		secret.NewRegistry(secretetcd.NewREST(s, storage.NoDecoration)),
+		secret.NewRegistry(secretetcd.NewREST(s, generic.UndecoratedStorage)),
 	)
 }

pkg/master/master.go

@@ -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()))
+	eventStorage := eventetcd.NewREST(dbClient("events"), storageDecorator, uint64(c.EventTTL.Seconds()))
-	limitRangeStorage := limitrangeetcd.NewREST(dbClient("limitRanges"), storageFactory)
+	limitRangeStorage := limitrangeetcd.NewREST(dbClient("limitRanges"), storageDecorator)
 
-	resourceQuotaStorage, resourceQuotaStatusStorage := resourcequotaetcd.NewREST(dbClient("resourceQuotas"), storageFactory)
+	resourceQuotaStorage, resourceQuotaStatusStorage := resourcequotaetcd.NewREST(dbClient("resourceQuotas"), storageDecorator)
-	secretStorage := secretetcd.NewREST(dbClient("secrets"), storageFactory)
+	secretStorage := secretetcd.NewREST(dbClient("secrets"), storageDecorator)
-	serviceAccountStorage := serviceaccountetcd.NewREST(dbClient("serviceAccounts"), storageFactory)
+	serviceAccountStorage := serviceaccountetcd.NewREST(dbClient("serviceAccounts"), storageDecorator)
-	persistentVolumeStorage, persistentVolumeStatusStorage := pvetcd.NewREST(dbClient("persistentVolumes"), storageFactory)
+	persistentVolumeStorage, persistentVolumeStatusStorage := pvetcd.NewREST(dbClient("persistentVolumes"), storageDecorator)
-	persistentVolumeClaimStorage, persistentVolumeClaimStatusStorage := pvcetcd.NewREST(dbClient("persistentVolumeClaims"), storageFactory)
+	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
 	}

pkg/registry/controller/etcd/etcd.go

@@ -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(
+	storageInterface := storageDecorator(
-		s, 100, nil, &api.ReplicationController{}, prefix, true, newListFunc)
+		s, 100, &api.ReplicationController{}, prefix, true, newListFunc)
 
 	store := &etcdgeneric.Etcd{
 		NewFunc: func() runtime.Object { return &api.ReplicationController{} },

pkg/registry/controller/etcd/etcd_test.go

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

pkg/registry/daemonset/etcd/etcd.go

@@ -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(
+	storageInterface := storageDecorator(
-		s, 100, nil, &extensions.DaemonSet{}, prefix, false, newListFunc)
+		s, 100, &extensions.DaemonSet{}, prefix, false, newListFunc)
 
 	store := &etcdgeneric.Etcd{
 		NewFunc: func() runtime.Object { return &extensions.DaemonSet{} },

pkg/registry/daemonset/etcd/etcd_test.go

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

pkg/registry/deployment/etcd/etcd.go

@@ -39,8 +39,8 @@ type DeploymentStorage struct {
 	Scale      *ScaleREST
 }
 
-func NewStorage(s storage.Interface, storageFactory storage.StorageFactory) DeploymentStorage {
+func NewStorage(s storage.Interface, storageDecorator generic.StorageDecorator) DeploymentStorage {
-	deploymentRest, deploymentStatusRest := NewREST(s, storageFactory)
+	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(
+	storageInterface := storageDecorator(
-		s, 100, nil, &extensions.Deployment{}, prefix, false, newListFunc)
+		s, 100, &extensions.Deployment{}, prefix, false, newListFunc)
 
 	store := &etcdgeneric.Etcd{
 		NewFunc: func() runtime.Object { return &extensions.Deployment{} },

pkg/registry/deployment/etcd/etcd_test.go

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

pkg/registry/endpoint/etcd/etcd.go

@@ -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(
+	storageInterface := storageDecorator(
-		s, 1000, nil, &api.Endpoints{}, prefix, true, newListFunc)
+		s, 1000, &api.Endpoints{}, prefix, true, newListFunc)
 
 	store := &etcdgeneric.Etcd{
 		NewFunc:     func() runtime.Object { return &api.Endpoints{} },

pkg/registry/endpoint/etcd/etcd_test.go

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

pkg/registry/event/etcd/etcd.go

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

pkg/registry/event/etcd/etcd_test.go

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

pkg/registry/experimental/controller/etcd/etcd.go

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

pkg/registry/experimental/controller/etcd/etcd_test.go

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

pkg/registry/generic/etcd/storage_factory.go

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

pkg/registry/generic/storage_decorator.go

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

pkg/registry/horizontalpodautoscaler/etcd/etcd.go

@@ -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(
+	storageInterface := storageDecorator(
-		s, 100, nil, &extensions.HorizontalPodAutoscaler{}, prefix, false, newListFunc)
+		s, 100, &extensions.HorizontalPodAutoscaler{}, prefix, false, newListFunc)
 
 	store := &etcdgeneric.Etcd{
 		NewFunc: func() runtime.Object { return &extensions.HorizontalPodAutoscaler{} },

pkg/registry/horizontalpodautoscaler/etcd/etcd_test.go

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

pkg/registry/ingress/etcd/etcd.go

@@ -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(
+	storageInterface := storageDecorator(
-		s, 100, nil, &extensions.Ingress{}, prefix, false, newListFunc)
+		s, 100, &extensions.Ingress{}, prefix, false, newListFunc)
 
 	store := &etcdgeneric.Etcd{
 		NewFunc: func() runtime.Object { return &extensions.Ingress{} },

pkg/registry/ingress/etcd/etcd_test.go

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

pkg/registry/job/etcd/etcd.go

@@ -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(
+	storageInterface := storageDecorator(
-		s, 100, nil, &extensions.Job{}, prefix, false, newListFunc)
+		s, 100, &extensions.Job{}, prefix, false, newListFunc)
 
 	store := &etcdgeneric.Etcd{
 		NewFunc: func() runtime.Object { return &extensions.Job{} },

pkg/registry/job/etcd/etcd_test.go

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

pkg/registry/limitrange/etcd/etcd.go

@@ -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(
+	storageInterface := storageDecorator(
-		s, 100, nil, &api.LimitRange{}, prefix, true, newListFunc)
+		s, 100, &api.LimitRange{}, prefix, true, newListFunc)
 
 	store := &etcdgeneric.Etcd{
 		NewFunc:     func() runtime.Object { return &api.LimitRange{} },

pkg/registry/limitrange/etcd/etcd_test.go

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

pkg/registry/namespace/etcd/etcd.go

@@ -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(
+	storageInterface := storageDecorator(
-		s, 100, nil, &api.Namespace{}, prefix, true, newListFunc)
+		s, 100, &api.Namespace{}, prefix, true, newListFunc)
 
 	store := &etcdgeneric.Etcd{
 		NewFunc:     func() runtime.Object { return &api.Namespace{} },

pkg/registry/namespace/etcd/etcd_test.go

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

pkg/registry/node/etcd/etcd.go

@@ -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(
+	storageInterface := storageDecorator(
-		s, 1000, nil, &api.Node{}, prefix, false, newListFunc)
+		s, 1000, &api.Node{}, prefix, false, newListFunc)
 
 	store := &etcdgeneric.Etcd{
 		NewFunc:     func() runtime.Object { return &api.Node{} },

pkg/registry/node/etcd/etcd_test.go

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

pkg/registry/persistentvolume/etcd/etcd.go

@@ -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(
+	storageInterface := storageDecorator(
-		s, 100, nil, &api.PersistentVolume{}, prefix, true, newListFunc)
+		s, 100, &api.PersistentVolume{}, prefix, true, newListFunc)
 
 	store := &etcdgeneric.Etcd{
 		NewFunc:     func() runtime.Object { return &api.PersistentVolume{} },

pkg/registry/persistentvolume/etcd/etcd_test.go

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

pkg/registry/persistentvolumeclaim/etcd/etcd.go

@@ -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(
+	storageInterface := storageDecorator(
-		s, 100, nil, &api.PersistentVolumeClaim{}, prefix, true, newListFunc)
+		s, 100, &api.PersistentVolumeClaim{}, prefix, true, newListFunc)
 
 	store := &etcdgeneric.Etcd{
 		NewFunc:     func() runtime.Object { return &api.PersistentVolumeClaim{} },

pkg/registry/persistentvolumeclaim/etcd/etcd_test.go

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

pkg/registry/pod/etcd/etcd.go

@@ -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(
+	storageInterface := storageDecorator(
-		s, 1000, nil, &api.Pod{}, prefix, true, newListFunc)
+		s, 1000, &api.Pod{}, prefix, true, newListFunc)
 
 	store := &etcdgeneric.Etcd{
 		NewFunc:     func() runtime.Object { return &api.Pod{} },

pkg/registry/pod/etcd/etcd_test.go

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

pkg/registry/podtemplate/etcd/etcd.go

@@ -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(
+	storageInterface := storageDecorator(
-		s, 100, nil, &api.PodTemplate{}, prefix, false, newListFunc)
+		s, 100, &api.PodTemplate{}, prefix, false, newListFunc)
 
 	store := &etcdgeneric.Etcd{
 		NewFunc:     func() runtime.Object { return &api.PodTemplate{} },

pkg/registry/podtemplate/etcd/etcd_test.go

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

pkg/registry/resourcequota/etcd/etcd.go

@@ -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(
+	storageInterface := storageDecorator(
-		s, 100, nil, &api.ResourceQuota{}, prefix, true, newListFunc)
+		s, 100, &api.ResourceQuota{}, prefix, true, newListFunc)
 
 	store := &etcdgeneric.Etcd{
 		NewFunc:     func() runtime.Object { return &api.ResourceQuota{} },

pkg/registry/resourcequota/etcd/etcd_test.go

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

pkg/registry/secret/etcd/etcd.go

@@ -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(
+	storageInterface := storageDecorator(
-		s, 100, nil, &api.Secret{}, prefix, true, newListFunc)
+		s, 100, &api.Secret{}, prefix, true, newListFunc)
 
 	store := &etcdgeneric.Etcd{
 		NewFunc:     func() runtime.Object { return &api.Secret{} },

pkg/registry/secret/etcd/etcd_test.go

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

pkg/registry/service/etcd/etcd.go

@@ -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(
+	storageInterface := storageDecorator(
-		s, 100, nil, &api.Service{}, prefix, false, newListFunc)
+		s, 100, &api.Service{}, prefix, false, newListFunc)
 
 	store := &etcdgeneric.Etcd{
 		NewFunc:     func() runtime.Object { return &api.Service{} },

pkg/registry/service/etcd/etcd_test.go

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

pkg/registry/serviceaccount/etcd/etcd.go

@@ -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(
+	storageInterface := storageDecorator(
-		s, 100, nil, &api.ServiceAccount{}, prefix, true, newListFunc)
+		s, 100, &api.ServiceAccount{}, prefix, true, newListFunc)
 
 	store := &etcdgeneric.Etcd{
 		NewFunc:     func() runtime.Object { return &api.ServiceAccount{} },

pkg/registry/serviceaccount/etcd/etcd_test.go

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

pkg/registry/thirdpartyresource/etcd/etcd.go

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

pkg/registry/thirdpartyresource/etcd/etcd_test.go

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

pkg/registry/thirdpartyresourcedata/etcd/etcd.go

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

pkg/registry/thirdpartyresourcedata/etcd/etcd_test.go

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

pkg/storage/cacher.go

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