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

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

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

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

pkg/registry/deployment/etcd/etcd_test.go

@@ -24,17 +24,17 @@ 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"
 )
 
 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(
- 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{} },

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,17 +22,17 @@ 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"
 )
 
 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{