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

In preparation for new storage backends renaming generic registry store

pull/6/head
Timothy St. Clair 2016-04-08 14:57:28 -05:00
parent 9db45590cf
commit 24b4286960
62 changed files with 374 additions and 375 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
contrib/mesos/pkg/scheduler/podtask/leaky.go
View File

@ -20,10 +20,10 @@ package podtask
import (
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
)
// makePodKey constructs etcd paths to pod items enforcing namespace rules.
func MakePodKey(ctx api.Context, id string) (string, error) {
return etcd.NamespaceKeyFunc(ctx, PodPath, id)
return registry.NamespaceKeyFunc(ctx, PodPath, id)
}

10
examples/apiserver/rest/reststorage.go
View File

@ -22,13 +22,13 @@ import (
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
)
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work with testtype.
@ -39,19 +39,19 @@ func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) *RE
strategy := &NotNamespaceScoped{}
storageInterface := storageDecorator(
s, 100, &testgroup.TestType{}, prefix, strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &testgroup.TestType{} },
// NewListFunc returns an object capable of storing results of an etcd list.
NewListFunc: newListFunc,
// Produces a path that etcd understands, to the root of the resource
// by combining the namespace in the context with the given prefix.
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
// Produces a path that etcd understands, to the resource by combining
// the namespace in the context with the given prefix.
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, name)
return registry.NamespaceKeyFunc(ctx, prefix, name)
},
// Retrieve the name field of the resource.
ObjectNameFunc: func(obj runtime.Object) (string, error) {

4
pkg/genericapiserver/genericapiserver.go
View File

@ -40,7 +40,7 @@ import (
"k8s.io/kubernetes/pkg/auth/authorizer"
"k8s.io/kubernetes/pkg/auth/handlers"
"k8s.io/kubernetes/pkg/registry/generic"
genericetcd "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
ipallocator "k8s.io/kubernetes/pkg/registry/service/ipallocator"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/ui"
@ -246,7 +246,7 @@ type GenericAPIServer struct {
func (s *GenericAPIServer) StorageDecorator() generic.StorageDecorator {
if s.enableWatchCache {
return genericetcd.StorageWithCacher
return registry.StorageWithCacher
}
return generic.UndecoratedStorage
}

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

@ -22,12 +22,12 @@ import (
"k8s.io/kubernetes/pkg/registry/generic"
"k8s.io/kubernetes/pkg/runtime"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
)
// REST implements a RESTStorage for ConfigMap against etcd
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work with ConfigMap objects.
@ -38,7 +38,7 @@ func NewREST(opts generic.RESTOptions) *REST {
storageInterface := opts.Decorator(
opts.Storage, 100, &api.ConfigMap{}, prefix, configmap.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object {
return &api.ConfigMap{}
},
@ -49,13 +49,13 @@ func NewREST(opts generic.RESTOptions) *REST {
// Produces a path that etcd understands, to the root of the resource
// by combining the namespace in the context with the given prefix.
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
// Produces a path that etcd understands, to the resource by combining
// the namespace in the context with the given prefix
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, name)
return registry.NamespaceKeyFunc(ctx, prefix, name)
},
// Retrieves the name field of a ConfigMap object.

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

@ -53,7 +53,7 @@ func validNewConfigMap() *api.ConfigMap {
func TestCreate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
validConfigMap := validNewConfigMap()
validConfigMap.ObjectMeta = api.ObjectMeta{
@ -80,7 +80,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestUpdate(
// valid
validNewConfigMap(),
@ -102,28 +102,28 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestDelete(validNewConfigMap())
}
func TestGet(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestGet(validNewConfigMap())
}
func TestList(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestList(validNewConfigMap())
}
func TestWatch(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestWatch(
validNewConfigMap(),
// matching labels

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

@ -31,7 +31,7 @@ import (
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/controller"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/runtime"
)
@ -54,7 +54,7 @@ func NewStorage(opts generic.RESTOptions) ControllerStorage {
}
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work against replication controllers.
@ -65,7 +65,7 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Controllers), &api.ReplicationController{}, prefix, controller.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &api.ReplicationController{} },
// NewListFunc returns an object capable of storing results of an etcd list.
@ -73,12 +73,12 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
// Produces a path that etcd understands, to the root of the resource
// by combining the namespace in the context with the given prefix
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
// Produces a path that etcd understands, to the resource by combining
// the namespace in the context with the given prefix
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, name)
return registry.NamespaceKeyFunc(ctx, prefix, name)
},
// Retrieve the name field of a replication controller
ObjectNameFunc: func(obj runtime.Object) (string, error) {
@ -109,7 +109,7 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
// StatusREST implements the REST endpoint for changing the status of a replication controller
type StatusREST struct {
store *etcdgeneric.Etcd
store *registry.Store
}
func (r *StatusREST) New() runtime.Object {

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

@ -87,7 +87,7 @@ var validController = validNewController()
func TestCreate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Controller.Etcd)
test := registrytest.New(t, storage.Controller.Store)
controller := validNewController()
controller.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -107,7 +107,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Controller.Etcd)
test := registrytest.New(t, storage.Controller.Store)
test.TestUpdate(
// valid
validNewController(),
@ -134,7 +134,7 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Controller.Etcd)
test := registrytest.New(t, storage.Controller.Store)
test.TestDelete(validNewController())
}
@ -191,21 +191,21 @@ func TestGenerationNumber(t *testing.T) {
func TestGet(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Controller.Etcd)
test := registrytest.New(t, storage.Controller.Store)
test.TestGet(validNewController())
}
func TestList(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Controller.Etcd)
test := registrytest.New(t, storage.Controller.Store)
test.TestList(validNewController())
}
func TestWatch(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Controller.Etcd)
test := registrytest.New(t, storage.Controller.Store)
test.TestWatch(
validController,
// matching labels

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

@ -24,13 +24,13 @@ import (
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/daemonset"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/runtime"
)
// rest implements a RESTStorage for DaemonSets against etcd
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work against DaemonSets.
@ -41,7 +41,7 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Daemonsets), &extensions.DaemonSet{}, prefix, daemonset.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &extensions.DaemonSet{} },
// NewListFunc returns an object capable of storing results of an etcd list.
@ -49,12 +49,12 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
// Produces a path that etcd understands, to the root of the resource
// by combining the namespace in the context with the given prefix
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
// Produces a path that etcd understands, to the resource by combining
// the namespace in the context with the given prefix
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, name)
return registry.NamespaceKeyFunc(ctx, prefix, name)
},
// Retrieve the name field of a daemon set
ObjectNameFunc: func(obj runtime.Object) (string, error) {
@ -84,7 +84,7 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
// StatusREST implements the REST endpoint for changing the status of a daemonset
type StatusREST struct {
store *etcdgeneric.Etcd
store *registry.Store
}
func (r *StatusREST) New() runtime.Object {

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

@ -70,7 +70,7 @@ var validDaemonSet = newValidDaemonSet()
func TestCreate(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
ds := newValidDaemonSet()
ds.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -96,7 +96,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestUpdate(
// valid
newValidDaemonSet(),
@ -124,28 +124,28 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestDelete(newValidDaemonSet())
}
func TestGet(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestGet(newValidDaemonSet())
}
func TestList(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestList(newValidDaemonSet())
}
func TestWatch(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestWatch(
validDaemonSet,
// matching labels

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

@ -30,7 +30,7 @@ import (
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/deployment"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
)
@ -56,7 +56,7 @@ func NewStorage(opts generic.RESTOptions) DeploymentStorage {
}
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work against deployments.
@ -67,19 +67,19 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST, *RollbackREST) {
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Deployments), &extensions.Deployment{}, prefix, deployment.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &extensions.Deployment{} },
// NewListFunc returns an object capable of storing results of an etcd list.
NewListFunc: newListFunc,
// Produces a path that etcd understands, to the root of the resource
// by combining the namespace in the context with the given prefix.
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
// Produces a path that etcd understands, to the resource by combining
// the namespace in the context with the given prefix.
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, name)
return registry.NamespaceKeyFunc(ctx, prefix, name)
},
// Retrieve the name field of a deployment.
ObjectNameFunc: func(obj runtime.Object) (string, error) {
@ -108,7 +108,7 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST, *RollbackREST) {
// StatusREST implements the REST endpoint for changing the status of a deployment
type StatusREST struct {
store *etcdgeneric.Etcd
store *registry.Store
}
func (r *StatusREST) New() runtime.Object {
@ -122,7 +122,7 @@ func (r *StatusREST) Update(ctx api.Context, obj runtime.Object) (runtime.Object
// RollbackREST implements the REST endpoint for initiating the rollback of a deployment
type RollbackREST struct {
store *etcdgeneric.Etcd
store *registry.Store
}
// New creates a rollback

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

@ -84,7 +84,7 @@ var validDeployment = *validNewDeployment()
func TestCreate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Deployment.Etcd)
test := registrytest.New(t, storage.Deployment.Store)
deployment := validNewDeployment()
deployment.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -103,7 +103,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Deployment.Etcd)
test := registrytest.New(t, storage.Deployment.Store)
test.TestUpdate(
// valid
validNewDeployment(),
@ -135,28 +135,28 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Deployment.Etcd)
test := registrytest.New(t, storage.Deployment.Store)
test.TestDelete(validNewDeployment())
}
func TestGet(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Deployment.Etcd)
test := registrytest.New(t, storage.Deployment.Store)
test.TestGet(validNewDeployment())
}
func TestList(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Deployment.Etcd)
test := registrytest.New(t, storage.Deployment.Store)
test.TestList(validNewDeployment())
}
func TestWatch(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Deployment.Etcd)
test := registrytest.New(t, storage.Deployment.Store)
test.TestWatch(
validNewDeployment(),
// matching labels

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

@ -23,12 +23,12 @@ import (
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/endpoint"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/runtime"
)
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work against endpoints.
@ -39,14 +39,14 @@ func NewREST(opts generic.RESTOptions) *REST {
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Endpoints), &api.Endpoints{}, prefix, endpoint.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &api.Endpoints{} },
NewListFunc: newListFunc,
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, name)
return registry.NamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.Endpoints).Name, nil

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

@ -60,7 +60,7 @@ func validChangedEndpoints() *api.Endpoints {
func TestCreate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
endpoints := validNewEndpoints()
endpoints.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -76,7 +76,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate()
test := registrytest.New(t, storage.Store).AllowCreateOnUpdate()
test.TestUpdate(
// valid
validNewEndpoints(),
@ -95,28 +95,28 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestDelete(validNewEndpoints())
}
func TestGet(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestGet(validNewEndpoints())
}
func TestList(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestList(validNewEndpoints())
}
func TestWatch(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestWatch(
validNewEndpoints(),
// matching labels

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

@ -22,12 +22,12 @@ import (
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/event"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/runtime"
)
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work against events.
@ -38,14 +38,14 @@ func NewREST(opts generic.RESTOptions, ttl uint64) *REST {
// for events will lead to too high memory consumption.
storageInterface := opts.Storage
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &api.Event{} },
NewListFunc: func() runtime.Object { return &api.EventList{} },
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
KeyFunc: func(ctx api.Context, id string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, id)
return registry.NamespaceKeyFunc(ctx, prefix, id)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.Event).Name, nil

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

@ -51,7 +51,7 @@ func validNewEvent(namespace string) *api.Event {
func TestCreate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
event := validNewEvent(test.TestNamespace())
event.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -65,7 +65,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate()
test := registrytest.New(t, storage.Store).AllowCreateOnUpdate()
test.TestUpdate(
// valid
validNewEvent(test.TestNamespace()),
@ -87,6 +87,6 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestDelete(validNewEvent(test.TestNamespace()))
}

2
pkg/registry/generic/etcd/doc.go → pkg/registry/generic/registry/doc.go
View File

@ -16,4 +16,4 @@ limitations under the License.
// Package etcd has a generic implementation of a registry that
// stores things in etcd.
package etcd
package registry

2
pkg/registry/generic/etcd/storage_factory.go → pkg/registry/generic/registry/storage_factory.go
View File

@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
package etcd
package registry
import (
"k8s.io/kubernetes/pkg/api/rest"

69
pkg/registry/generic/etcd/etcd.go → pkg/registry/generic/registry/store.go
View File

@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
package etcd
package registry
import (
"fmt"
@ -40,7 +40,7 @@ import (
"github.com/golang/glog"
)
// Etcd implements generic.Registry, backing it with etcd storage.
// Store implements generic.Registry.
// It's intended to be embeddable, so that you can implement any
// non-generic functions if needed.
// You must supply a value for every field below before use; these are
@ -56,9 +56,7 @@ import (
// logic specific to the API.
//
// TODO: make the default exposed methods exactly match a generic RESTStorage
// TODO: because all aspects of etcd have been removed it should really
// just be called a registry implementation.
type Etcd struct {
type Store struct {
// Called to make a new object, should return e.g., &api.Pod{}
NewFunc func() runtime.Object
@ -92,8 +90,8 @@ type Etcd struct {
// Called on all objects returned from the underlying store, after
// the exit hooks are invoked. Decorators are intended for integrations
// that are above etcd and should only be used for specific cases where
// storage of the value in etcd is not appropriate, since they cannot
// that are above storage and should only be used for specific cases where
// storage of the value is not appropriate, since they cannot
// be watched.
Decorator rest.ObjectFunc
// Allows extended behavior during creation, required
@ -114,11 +112,11 @@ type Etcd struct {
// Allows extended behavior during export, optional
ExportStrategy rest.RESTExportStrategy
// Used for all etcd access functions
// Used for all storage access functions
Storage storage.Interface
}
// NamespaceKeyRootFunc is the default function for constructing etcd paths to resource directories enforcing namespace rules.
// NamespaceKeyRootFunc is the default function for constructing storage paths to resource directories enforcing namespace rules.
func NamespaceKeyRootFunc(ctx api.Context, prefix string) string {
key := prefix
ns, ok := api.NamespaceFrom(ctx)
@ -128,7 +126,7 @@ func NamespaceKeyRootFunc(ctx api.Context, prefix string) string {
return key
}
// NamespaceKeyFunc is the default function for constructing etcd paths to a resource relative to prefix enforcing namespace rules.
// NamespaceKeyFunc is the default function for constructing storage paths to a resource relative to prefix enforcing namespace rules.
// If no namespace is on context, it errors.
func NamespaceKeyFunc(ctx api.Context, prefix string, name string) (string, error) {
key := NamespaceKeyRootFunc(ctx, prefix)
@ -146,7 +144,7 @@ func NamespaceKeyFunc(ctx api.Context, prefix string, name string) (string, erro
return key, nil
}
// NoNamespaceKeyFunc is the default function for constructing etcd paths to a resource relative to prefix without a namespace
// NoNamespaceKeyFunc is the default function for constructing storage paths to a resource relative to prefix without a namespace
func NoNamespaceKeyFunc(ctx api.Context, prefix string, name string) (string, error) {
if len(name) == 0 {
return "", kubeerr.NewBadRequest("Name parameter required.")
@ -159,17 +157,17 @@ func NoNamespaceKeyFunc(ctx api.Context, prefix string, name string) (string, er
}
// New implements RESTStorage
func (e *Etcd) New() runtime.Object {
func (e *Store) New() runtime.Object {
return e.NewFunc()
}
// NewList implements RESTLister
func (e *Etcd) NewList() runtime.Object {
func (e *Store) NewList() runtime.Object {
return e.NewListFunc()
}
// List returns a list of items matching labels and field
func (e *Etcd) List(ctx api.Context, options *api.ListOptions) (runtime.Object, error) {
func (e *Store) List(ctx api.Context, options *api.ListOptions) (runtime.Object, error) {
label := labels.Everything()
if options != nil && options.LabelSelector != nil {
label = options.LabelSelector
@ -182,7 +180,7 @@ func (e *Etcd) List(ctx api.Context, options *api.ListOptions) (runtime.Object,
}
// ListPredicate returns a list of all the items matching m.
func (e *Etcd) ListPredicate(ctx api.Context, m generic.Matcher, options *api.ListOptions) (runtime.Object, error) {
func (e *Store) ListPredicate(ctx api.Context, m generic.Matcher, options *api.ListOptions) (runtime.Object, error) {
list := e.NewListFunc()
filterFunc := e.filterAndDecorateFunction(m)
if name, ok := m.MatchesSingle(); ok {
@ -201,7 +199,7 @@ func (e *Etcd) ListPredicate(ctx api.Context, m generic.Matcher, options *api.Li
}
// Create inserts a new item according to the unique key from the object.
func (e *Etcd) Create(ctx api.Context, obj runtime.Object) (runtime.Object, error) {
func (e *Store) Create(ctx api.Context, obj runtime.Object) (runtime.Object, error) {
if err := rest.BeforeCreate(e.CreateStrategy, ctx, obj); err != nil {
return nil, err
}
@ -239,7 +237,7 @@ func (e *Etcd) Create(ctx api.Context, obj runtime.Object) (runtime.Object, erro
// Update performs an atomic update and set of the object. Returns the result of the update
// or an error. If the registry allows create-on-update, the create flow will be executed.
// A bool is returned along with the object and any errors, to indicate object creation.
func (e *Etcd) Update(ctx api.Context, obj runtime.Object) (runtime.Object, bool, error) {
func (e *Store) Update(ctx api.Context, obj runtime.Object) (runtime.Object, bool, error) {
name, err := e.ObjectNameFunc(obj)
if err != nil {
return nil, false, err
@ -250,7 +248,7 @@ func (e *Etcd) Update(ctx api.Context, obj runtime.Object) (runtime.Object, bool
}
// If AllowUnconditionalUpdate() is true and the object specified by the user does not have a resource version,
// then we populate it with the latest version.
// Else, we check that the version specified by the user matches the version of latest etcd object.
// Else, we check that the version specified by the user matches the version of latest storage object.
resourceVersion, err := e.Storage.Versioner().ObjectResourceVersion(obj)
if err != nil {
return nil, false, err
@ -300,7 +298,7 @@ func (e *Etcd) Update(ctx api.Context, obj runtime.Object) (runtime.Object, bool
creating = false
if doUnconditionalUpdate {
// Update the object's resource version to match the latest etcd object's resource version.
// Update the object's resource version to match the latest storage object's resource version.
err = e.Storage.Versioner().UpdateObject(obj, res.ResourceVersion)
if err != nil {
return nil, nil, err
@ -366,8 +364,8 @@ func (e *Etcd) Update(ctx api.Context, obj runtime.Object) (runtime.Object, bool
return out, creating, nil
}
// Get retrieves the item from etcd.
func (e *Etcd) Get(ctx api.Context, name string) (runtime.Object, error) {
// Get retrieves the item from storage.
func (e *Store) Get(ctx api.Context, name string) (runtime.Object, error) {
obj := e.NewFunc()
key, err := e.KeyFunc(ctx, name)
if err != nil {
@ -389,8 +387,8 @@ var (
errDeleteNow = fmt.Errorf("delete now")
)
// Delete removes the item from etcd.
func (e *Etcd) Delete(ctx api.Context, name string, options *api.DeleteOptions) (runtime.Object, error) {
// Delete removes the item from storage.
func (e *Store) Delete(ctx api.Context, name string, options *api.DeleteOptions) (runtime.Object, error) {
key, err := e.KeyFunc(ctx, name)
if err != nil {
return nil, err
@ -478,17 +476,17 @@ func (e *Etcd) Delete(ctx api.Context, name string, options *api.DeleteOptions)
return e.finalizeDelete(out, true)
}
// DeleteCollection remove all items returned by List with a given ListOptions from etcd.
// DeleteCollection remove all items returned by List with a given ListOptions from storage.
//
// DeleteCollection is currently NOT atomic. It can happen that only subset of objects
// will be deleted from etcd, and then an error will be returned.
// will be deleted from storage, and then an error will be returned.
// In case of success, the list of deleted objects will be returned.
//
// TODO: Currently, there is no easy way to remove 'directory' entry from etcd (if we
// TODO: Currently, there is no easy way to remove 'directory' entry from storage (if we
// are removing all objects of a given type) with the current API (it's technically
// possibly with etcd API, but watch is not delivered correctly then).
// possibly with storage API, but watch is not delivered correctly then).
// It will be possible to fix it with v3 etcd API.
func (e *Etcd) DeleteCollection(ctx api.Context, options *api.DeleteOptions, listOptions *api.ListOptions) (runtime.Object, error) {
func (e *Store) DeleteCollection(ctx api.Context, options *api.DeleteOptions, listOptions *api.ListOptions) (runtime.Object, error) {
listObj, err := e.List(ctx, listOptions)
if err != nil {
return nil, err
@ -497,7 +495,7 @@ func (e *Etcd) DeleteCollection(ctx api.Context, options *api.DeleteOptions, lis
if err != nil {
return nil, err
}
// Spawn a number of goroutines, so that we can issue requests to etcd
// Spawn a number of goroutines, so that we can issue requests to storage
// in parallel to speed up deletion.
// TODO: Make this proportional to the number of items to delete, up to
// DeleteCollectionWorkers (it doesn't make much sense to spawn 16
@ -556,7 +554,7 @@ func (e *Etcd) DeleteCollection(ctx api.Context, options *api.DeleteOptions, lis
}
}
func (e *Etcd) finalizeDelete(obj runtime.Object, runHooks bool) (runtime.Object, error) {
func (e *Store) finalizeDelete(obj runtime.Object, runHooks bool) (runtime.Object, error) {
if runHooks && e.AfterDelete != nil {
if err := e.AfterDelete(obj); err != nil {
return nil, err
@ -577,7 +575,7 @@ func (e *Etcd) finalizeDelete(obj runtime.Object, runHooks bool) (runtime.Object
// WatchPredicate. If possible, you should customize PredicateFunc to produre a
// matcher that matches by key. generic.SelectionPredicate does this for you
// automatically.
func (e *Etcd) Watch(ctx api.Context, options *api.ListOptions) (watch.Interface, error) {
func (e *Store) Watch(ctx api.Context, options *api.ListOptions) (watch.Interface, error) {
label := labels.Everything()
if options != nil && options.LabelSelector != nil {
label = options.LabelSelector
@ -594,7 +592,7 @@ func (e *Etcd) Watch(ctx api.Context, options *api.ListOptions) (watch.Interface
}
// WatchPredicate starts a watch for the items that m matches.
func (e *Etcd) WatchPredicate(ctx api.Context, m generic.Matcher, resourceVersion string) (watch.Interface, error) {
func (e *Store) WatchPredicate(ctx api.Context, m generic.Matcher, resourceVersion string) (watch.Interface, error) {
filterFunc := e.filterAndDecorateFunction(m)
if name, ok := m.MatchesSingle(); ok {
@ -610,7 +608,7 @@ func (e *Etcd) WatchPredicate(ctx api.Context, m generic.Matcher, resourceVersio
return e.Storage.WatchList(ctx, e.KeyRootFunc(ctx), resourceVersion, filterFunc)
}
func (e *Etcd) filterAndDecorateFunction(m generic.Matcher) func(runtime.Object) bool {
func (e *Store) filterAndDecorateFunction(m generic.Matcher) func(runtime.Object) bool {
return func(obj runtime.Object) bool {
matches, err := m.Matches(obj)
if err != nil {
@ -630,7 +628,8 @@ func (e *Etcd) filterAndDecorateFunction(m generic.Matcher) func(runtime.Object)
// calculateTTL is a helper for retrieving the updated TTL for an object or returning an error
// if the TTL cannot be calculated. The defaultTTL is changed to 1 if less than zero. Zero means
// no TTL, not expire immediately.
func (e *Etcd) calculateTTL(obj runtime.Object, defaultTTL int64, update bool) (ttl uint64, err error) {
func (e *Store) calculateTTL(obj runtime.Object, defaultTTL int64, update bool) (ttl uint64, err error) {
// TODO: validate this is assertion is still valid.
// etcd may return a negative TTL for a node if the expiration has not occurred due
// to server lag - we will ensure that the value is at least set.
if defaultTTL < 0 {
@ -658,7 +657,7 @@ func exportObjectMeta(accessor meta.Object, exact bool) {
}
// Implements the rest.Exporter interface
func (e *Etcd) Export(ctx api.Context, name string, opts unversioned.ExportOptions) (runtime.Object, error) {
func (e *Store) Export(ctx api.Context, name string, opts unversioned.ExportOptions) (runtime.Object, error) {
obj, err := e.Get(ctx, name)
if err != nil {
return nil, err

54
pkg/registry/generic/etcd/etcd_test.go → pkg/registry/generic/registry/store_test.go
View File

@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
package etcd
package registry
import (
"fmt"
@ -87,13 +87,13 @@ func hasCreated(t *testing.T, pod *api.Pod) func(runtime.Object) bool {
}
}
func NewTestGenericEtcdRegistry(t *testing.T) (*etcdtesting.EtcdTestServer, *Etcd) {
func NewTestGenericStoreRegistry(t *testing.T) (*etcdtesting.EtcdTestServer, *Store) {
podPrefix := "/pods"
server := etcdtesting.NewEtcdTestClientServer(t)
s := etcdstorage.NewEtcdStorage(server.Client, testapi.Default.Codec(), etcdtest.PathPrefix(), false, etcdtest.DeserializationCacheSize)
strategy := &testRESTStrategy{api.Scheme, api.SimpleNameGenerator, true, false, true}
return server, &Etcd{
return server, &Store{
NewFunc: func() runtime.Object { return &api.Pod{} },
NewListFunc: func() runtime.Object { return &api.PodList{} },
QualifiedResource: api.Resource("pods"),
@ -160,7 +160,7 @@ func (everythingMatcher) MatchesSingle() (string, bool) {
return "", false
}
func TestEtcdList(t *testing.T) {
func TestStoreList(t *testing.T) {
podA := &api.Pod{
ObjectMeta: api.ObjectMeta{Namespace: "test", Name: "bar"},
Spec: api.PodSpec{NodeName: "machine"},
@ -212,7 +212,7 @@ func TestEtcdList(t *testing.T) {
if item.context != nil {
ctx = item.context
}
server, registry := NewTestGenericEtcdRegistry(t)
server, registry := NewTestGenericStoreRegistry(t)
if item.in != nil {
if err := storagetesting.CreateList("/pods", registry.Storage, item.in); err != nil {
@ -234,7 +234,7 @@ func TestEtcdList(t *testing.T) {
}
}
func TestEtcdCreate(t *testing.T) {
func TestStoreCreate(t *testing.T) {
podA := &api.Pod{
ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "test"},
Spec: api.PodSpec{NodeName: "machine"},
@ -245,7 +245,7 @@ func TestEtcdCreate(t *testing.T) {
}
testContext := api.WithNamespace(api.NewContext(), "test")
server, registry := NewTestGenericEtcdRegistry(t)
server, registry := NewTestGenericStoreRegistry(t)
defer server.Terminate(t)
// create the object
@ -272,7 +272,7 @@ func TestEtcdCreate(t *testing.T) {
}
}
func updateAndVerify(t *testing.T, ctx api.Context, registry *Etcd, pod *api.Pod) bool {
func updateAndVerify(t *testing.T, ctx api.Context, registry *Store, pod *api.Pod) bool {
obj, _, err := registry.Update(ctx, pod)
if err != nil {
t.Errorf("Unexpected error: %v", err)
@ -290,7 +290,7 @@ func updateAndVerify(t *testing.T, ctx api.Context, registry *Etcd, pod *api.Pod
return true
}
func TestEtcdUpdate(t *testing.T) {
func TestStoreUpdate(t *testing.T) {
podA := &api.Pod{
ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "test"},
Spec: api.PodSpec{NodeName: "machine"},
@ -305,7 +305,7 @@ func TestEtcdUpdate(t *testing.T) {
}
testContext := api.WithNamespace(api.NewContext(), "test")
server, registry := NewTestGenericEtcdRegistry(t)
server, registry := NewTestGenericStoreRegistry(t)
defer server.Terminate(t)
// Test1 try to update a non-existing node
@ -343,7 +343,7 @@ func TestEtcdUpdate(t *testing.T) {
}
func TestNoOpUpdates(t *testing.T) {
server, registry := NewTestGenericEtcdRegistry(t)
server, registry := NewTestGenericStoreRegistry(t)
defer server.Terminate(t)
newPod := func() *api.Pod {
@ -414,7 +414,7 @@ func (t testPodExport) Export(obj runtime.Object, exact bool) error {
return nil
}
func TestEtcdCustomExport(t *testing.T) {
func TestStoreCustomExport(t *testing.T) {
podA := api.Pod{
ObjectMeta: api.ObjectMeta{
Namespace: "test",
@ -424,7 +424,7 @@ func TestEtcdCustomExport(t *testing.T) {
Spec: api.PodSpec{NodeName: "machine"},
}
server, registry := NewTestGenericEtcdRegistry(t)
server, registry := NewTestGenericStoreRegistry(t)
defer server.Terminate(t)
registry.ExportStrategy = testPodExport{}
@ -455,7 +455,7 @@ func TestEtcdCustomExport(t *testing.T) {
}
}
func TestEtcdBasicExport(t *testing.T) {
func TestStoreBasicExport(t *testing.T) {
podA := api.Pod{
ObjectMeta: api.ObjectMeta{
Namespace: "test",
@ -466,7 +466,7 @@ func TestEtcdBasicExport(t *testing.T) {
Status: api.PodStatus{HostIP: "1.2.3.4"},
}
server, registry := NewTestGenericEtcdRegistry(t)
server, registry := NewTestGenericStoreRegistry(t)
defer server.Terminate(t)
testContext := api.WithNamespace(api.NewContext(), "test")
@ -490,14 +490,14 @@ func TestEtcdBasicExport(t *testing.T) {
}
}
func TestEtcdGet(t *testing.T) {
func TestStoreGet(t *testing.T) {
podA := &api.Pod{
ObjectMeta: api.ObjectMeta{Namespace: "test", Name: "foo"},
Spec: api.PodSpec{NodeName: "machine"},
}
testContext := api.WithNamespace(api.NewContext(), "test")
server, registry := NewTestGenericEtcdRegistry(t)
server, registry := NewTestGenericStoreRegistry(t)
defer server.Terminate(t)
_, err := registry.Get(testContext, podA.Name)
@ -511,14 +511,14 @@ func TestEtcdGet(t *testing.T) {
}
}
func TestEtcdDelete(t *testing.T) {
func TestStoreDelete(t *testing.T) {
podA := &api.Pod{
ObjectMeta: api.ObjectMeta{Name: "foo"},
Spec: api.PodSpec{NodeName: "machine"},
}
testContext := api.WithNamespace(api.NewContext(), "test")
server, registry := NewTestGenericEtcdRegistry(t)
server, registry := NewTestGenericStoreRegistry(t)
defer server.Terminate(t)
// test failure condition
@ -546,12 +546,12 @@ func TestEtcdDelete(t *testing.T) {
}
}
func TestEtcdDeleteCollection(t *testing.T) {
func TestStoreDeleteCollection(t *testing.T) {
podA := &api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo"}}
podB := &api.Pod{ObjectMeta: api.ObjectMeta{Name: "bar"}}
testContext := api.WithNamespace(api.NewContext(), "test")
server, registry := NewTestGenericEtcdRegistry(t)
server, registry := NewTestGenericStoreRegistry(t)
defer server.Terminate(t)
if _, err := registry.Create(testContext, podA); err != nil {
@ -579,8 +579,8 @@ func TestEtcdDeleteCollection(t *testing.T) {
}
}
func TestEtcdDeleteCollectionNotFound(t *testing.T) {
server, registry := NewTestGenericEtcdRegistry(t)
func TestStoreDeleteCollectionNotFound(t *testing.T) {
server, registry := NewTestGenericStoreRegistry(t)
defer server.Terminate(t)
testContext := api.WithNamespace(api.NewContext(), "test")
@ -622,11 +622,11 @@ func TestEtcdDeleteCollectionNotFound(t *testing.T) {
// Test whether objects deleted with DeleteCollection are correctly delivered
// to watchers.
func TestEtcdDeleteCollectionWithWatch(t *testing.T) {
func TestStoreDeleteCollectionWithWatch(t *testing.T) {
podA := &api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo"}}
testContext := api.WithNamespace(api.NewContext(), "test")
server, registry := NewTestGenericEtcdRegistry(t)
server, registry := NewTestGenericStoreRegistry(t)
defer server.Terminate(t)
objCreated, err := registry.Create(testContext, podA)
@ -660,7 +660,7 @@ func TestEtcdDeleteCollectionWithWatch(t *testing.T) {
}
}
func TestEtcdWatch(t *testing.T) {
func TestStoreWatch(t *testing.T) {
testContext := api.WithNamespace(api.NewContext(), "test")
noNamespaceContext := api.NewContext()
@ -693,7 +693,7 @@ func TestEtcdWatch(t *testing.T) {
Spec: api.PodSpec{NodeName: "machine"},
}
server, registry := NewTestGenericEtcdRegistry(t)
server, registry := NewTestGenericStoreRegistry(t)
wi, err := registry.WatchPredicate(ctx, m, "0")
if err != nil {
t.Errorf("%v: unexpected error: %v", name, err)

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

@ -23,13 +23,13 @@ import (
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/registry/horizontalpodautoscaler"
"k8s.io/kubernetes/pkg/runtime"
)
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work against horizontal pod autoscalers.
@ -40,19 +40,19 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.HorizontalPodAutoscalers), &extensions.HorizontalPodAutoscaler{}, prefix, horizontalpodautoscaler.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &extensions.HorizontalPodAutoscaler{} },
// NewListFunc returns an object capable of storing results of an etcd list.
NewListFunc: newListFunc,
// Produces a path that etcd understands, to the root of the resource
// by combining the namespace in the context with the given prefix
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
// Produces a path that etcd understands, to the resource by combining
// the namespace in the context with the given prefix
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, name)
return registry.NamespaceKeyFunc(ctx, prefix, name)
},
// Retrieve the name field of an autoscaler
ObjectNameFunc: func(obj runtime.Object) (string, error) {
@ -81,7 +81,7 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
// StatusREST implements the REST endpoint for changing the status of a daemonset
type StatusREST struct {
store *etcdgeneric.Etcd
store *registry.Store
}
func (r *StatusREST) New() runtime.Object {

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

@ -59,7 +59,7 @@ func validNewHorizontalPodAutoscaler(name string) *extensions.HorizontalPodAutos
func TestCreate(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
autoscaler := validNewHorizontalPodAutoscaler("foo")
autoscaler.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -73,7 +73,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestUpdate(
// valid
validNewHorizontalPodAutoscaler("foo"),
@ -89,28 +89,28 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestDelete(validNewHorizontalPodAutoscaler("foo"))
}
func TestGet(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestGet(validNewHorizontalPodAutoscaler("foo"))
}
func TestList(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestList(validNewHorizontalPodAutoscaler("foo"))
}
func TestWatch(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestWatch(
validNewHorizontalPodAutoscaler("foo"),
// matching labels

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

@ -23,14 +23,14 @@ import (
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
ingress "k8s.io/kubernetes/pkg/registry/ingress"
"k8s.io/kubernetes/pkg/runtime"
)
// rest implements a RESTStorage for replication controllers against etcd
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work against replication controllers.
@ -41,7 +41,7 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Ingress), &extensions.Ingress{}, prefix, ingress.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &extensions.Ingress{} },
// NewListFunc returns an object capable of storing results of an etcd list.
@ -49,12 +49,12 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
// Produces a ingress that etcd understands, to the root of the resource
// by combining the namespace in the context with the given prefix
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
// Produces a ingress that etcd understands, to the resource by combining
// the namespace in the context with the given prefix
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, name)
return registry.NamespaceKeyFunc(ctx, prefix, name)
},
// Retrieve the name field of a replication controller
ObjectNameFunc: func(obj runtime.Object) (string, error) {
@ -83,7 +83,7 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
// StatusREST implements the REST endpoint for changing the status of an ingress
type StatusREST struct {
store *etcdgeneric.Etcd
store *registry.Store
}
func (r *StatusREST) New() runtime.Object {

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

@ -115,7 +115,7 @@ func validIngress() *extensions.Ingress {
func TestCreate(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
ingress := validIngress()
noDefaultBackendAndRules := validIngress()
noDefaultBackendAndRules.Spec.Backend = &extensions.IngressBackend{}
@ -134,7 +134,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestUpdate(
// valid
validIngress(),
@ -169,28 +169,28 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestDelete(validIngress())
}
func TestGet(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestGet(validIngress())
}
func TestList(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestList(validIngress())
}
func TestWatch(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestWatch(
validIngress(),
// matching labels

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

@ -23,14 +23,14 @@ import (
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/registry/job"
"k8s.io/kubernetes/pkg/runtime"
)
// REST implements a RESTStorage for jobs against etcd
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work against Jobs.
@ -41,7 +41,7 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Jobs), &batch.Job{}, prefix, job.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &batch.Job{} },
// NewListFunc returns an object capable of storing results of an etcd list.
@ -49,12 +49,12 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
// Produces a path that etcd understands, to the root of the resource
// by combining the namespace in the context with the given prefix
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
// Produces a path that etcd understands, to the resource by combining
// the namespace in the context with the given prefix
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, name)
return registry.NamespaceKeyFunc(ctx, prefix, name)
},
// Retrieve the name field of a job
ObjectNameFunc: func(obj runtime.Object) (string, error) {
@ -85,7 +85,7 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
// StatusREST implements the REST endpoint for changing the status of a resourcequota.
type StatusREST struct {
store *etcdgeneric.Etcd
store *registry.Store
}
func (r *StatusREST) New() runtime.Object {

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

@ -76,7 +76,7 @@ func validNewJob() *batch.Job {
func TestCreate(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
validJob := validNewJob()
validJob.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -96,7 +96,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
two := 2
test.TestUpdate(
// valid
@ -124,28 +124,28 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestDelete(validNewJob())
}
func TestGet(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestGet(validNewJob())
}
func TestList(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestList(validNewJob())
}
func TestWatch(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestWatch(
validNewJob(),
// matching labels

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

@ -22,13 +22,13 @@ import (
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/registry/limitrange"
"k8s.io/kubernetes/pkg/runtime"
)
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work against horizontal pod autoscalers.
@ -39,14 +39,14 @@ func NewREST(opts generic.RESTOptions) *REST {
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.LimitRanges), &api.LimitRange{}, prefix, limitrange.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &api.LimitRange{} },
NewListFunc: newListFunc,
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
KeyFunc: func(ctx api.Context, id string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, id)
return registry.NamespaceKeyFunc(ctx, prefix, id)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.LimitRange).Name, nil

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

@ -62,7 +62,7 @@ func validNewLimitRange() *api.LimitRange {
func TestCreate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).GeneratesName()
test := registrytest.New(t, storage.Store).GeneratesName()
validLimitRange := validNewLimitRange()
validLimitRange.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -78,7 +78,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate()
test := registrytest.New(t, storage.Store).AllowCreateOnUpdate()
test.TestUpdate(
// valid
validNewLimitRange(),
@ -106,28 +106,28 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestDelete(validNewLimitRange())
}
func TestGet(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestGet(validNewLimitRange())
}
func TestList(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestList(validNewLimitRange())
}
func TestWatch(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestWatch(
validNewLimitRange(),
// matching labels

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

@ -26,25 +26,25 @@ import (
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/registry/namespace"
"k8s.io/kubernetes/pkg/runtime"
)
// rest implements a RESTStorage for namespaces against etcd
type REST struct {
*etcdgeneric.Etcd
status *etcdgeneric.Etcd
*registry.Store
status *registry.Store
}
// StatusREST implements the REST endpoint for changing the status of a namespace.
type StatusREST struct {
store *etcdgeneric.Etcd
store *registry.Store
}
// FinalizeREST implements the REST endpoint for finalizing a namespace.
type FinalizeREST struct {
store *etcdgeneric.Etcd
store *registry.Store
}
// NewREST returns a RESTStorage object that will work against namespaces.
@ -55,14 +55,14 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST, *FinalizeREST) {
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Namespaces), &api.Namespace{}, prefix, namespace.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &api.Namespace{} },
NewListFunc: newListFunc,
KeyRootFunc: func(ctx api.Context) string {
return prefix
},
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NoNamespaceKeyFunc(ctx, prefix, name)
return registry.NoNamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.Namespace).Name, nil
@ -87,7 +87,7 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST, *FinalizeREST) {
finalizeStore := *store
finalizeStore.UpdateStrategy = namespace.FinalizeStrategy
return &REST{Etcd: store, status: &statusStore}, &StatusREST{store: &statusStore}, &FinalizeREST{store: &finalizeStore}
return &REST{Store: store, status: &statusStore}, &StatusREST{store: &statusStore}, &FinalizeREST{store: &finalizeStore}
}
// Delete enforces life-cycle rules for namespace termination
@ -113,7 +113,7 @@ func (r *REST) Delete(ctx api.Context, name string, options *api.DeleteOptions)
err = apierrors.NewConflict(api.Resource("namespaces"), namespace.Name, fmt.Errorf("The system is ensuring all content is removed from this namespace. Upon completion, this namespace will automatically be purged by the system."))
return nil, err
}
return r.Etcd.Delete(ctx, name, nil)
return r.Store.Delete(ctx, name, nil)
}
func (r *StatusREST) New() runtime.Object {

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

@ -47,7 +47,7 @@ func validNewNamespace() *api.Namespace {
func TestCreate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
namespace := validNewNamespace()
namespace.ObjectMeta = api.ObjectMeta{GenerateName: "foo"}
test.TestCreate(
@ -89,28 +89,28 @@ func TestCreateSetsFields(t *testing.T) {
func TestDelete(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope().ReturnDeletedObject()
test := registrytest.New(t, storage.Store).ClusterScope().ReturnDeletedObject()
test.TestDelete(validNewNamespace())
}
func TestGet(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
test.TestGet(validNewNamespace())
}
func TestList(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
test.TestList(validNewNamespace())
}
func TestWatch(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
test.TestWatch(
validNewNamespace(),
// matching labels

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

@ -26,7 +26,7 @@ import (
"k8s.io/kubernetes/pkg/kubelet/client"
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/registry/node"
noderest "k8s.io/kubernetes/pkg/registry/node/rest"
"k8s.io/kubernetes/pkg/runtime"
@ -40,14 +40,14 @@ type NodeStorage struct {
}
type REST struct {
*etcdgeneric.Etcd
*registry.Store
connection client.ConnectionInfoGetter
proxyTransport http.RoundTripper
}
// StatusREST implements the REST endpoint for changing the status of a pod.
type StatusREST struct {
store *etcdgeneric.Etcd
store *registry.Store
}
func (r *StatusREST) New() runtime.Object {
@ -67,14 +67,14 @@ func NewStorage(opts generic.RESTOptions, connection client.ConnectionInfoGetter
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Nodes), &api.Node{}, prefix, node.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &api.Node{} },
NewListFunc: newListFunc,
KeyRootFunc: func(ctx api.Context) string {
return prefix
},
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NoNamespaceKeyFunc(ctx, prefix, name)
return registry.NoNamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.Node).Name, nil

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

@ -67,7 +67,7 @@ func validNewNode() *api.Node {
func TestCreate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
node := validNewNode()
node.ObjectMeta = api.ObjectMeta{GenerateName: "foo"}
test.TestCreate(
@ -83,7 +83,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
test.TestUpdate(
// valid
validNewNode(),
@ -99,28 +99,28 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
test.TestDelete(validNewNode())
}
func TestGet(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
test.TestGet(validNewNode())
}
func TestList(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
test.TestList(validNewNode())
}
func TestWatch(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
test.TestWatch(
validNewNode(),
// matching labels

4
pkg/registry/node/rest/proxy.go
View File

@ -26,7 +26,7 @@ import (
"k8s.io/kubernetes/pkg/api/rest"
"k8s.io/kubernetes/pkg/capabilities"
"k8s.io/kubernetes/pkg/kubelet/client"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
genericrest "k8s.io/kubernetes/pkg/registry/generic/rest"
"k8s.io/kubernetes/pkg/registry/node"
"k8s.io/kubernetes/pkg/runtime"
@ -34,7 +34,7 @@ import (
// ProxyREST implements the proxy subresource for a Node
type ProxyREST struct {
Store *etcdgeneric.Etcd
Store *registry.Store
Connection client.ConnectionInfoGetter
ProxyTransport http.RoundTripper
}

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

@ -22,13 +22,13 @@ import (
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/registry/persistentvolume"
"k8s.io/kubernetes/pkg/runtime"
)
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work against persistent volumes.
@ -39,14 +39,14 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.PersistentVolumes), &api.PersistentVolume{}, prefix, persistentvolume.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &api.PersistentVolume{} },
NewListFunc: newListFunc,
KeyRootFunc: func(ctx api.Context) string {
return prefix
},
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NoNamespaceKeyFunc(ctx, prefix, name)
return registry.NoNamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.PersistentVolume).Name, nil
@ -73,7 +73,7 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
// StatusREST implements the REST endpoint for changing the status of a persistentvolume.
type StatusREST struct {
store *etcdgeneric.Etcd
store *registry.Store
}
func (r *StatusREST) New() runtime.Object {

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

@ -70,7 +70,7 @@ func validChangedPersistentVolume() *api.PersistentVolume {
func TestCreate(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
pv := validNewPersistentVolume("foo")
pv.ObjectMeta = api.ObjectMeta{GenerateName: "foo"}
test.TestCreate(
@ -86,7 +86,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
test.TestUpdate(
// valid
validNewPersistentVolume("foo"),
@ -104,28 +104,28 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope().ReturnDeletedObject()
test := registrytest.New(t, storage.Store).ClusterScope().ReturnDeletedObject()
test.TestDelete(validNewPersistentVolume("foo"))
}
func TestGet(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
test.TestGet(validNewPersistentVolume("foo"))
}
func TestList(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
test.TestList(validNewPersistentVolume("foo"))
}
func TestWatch(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
test.TestWatch(
validNewPersistentVolume("foo"),
// matching labels

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

@ -22,13 +22,13 @@ import (
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/registry/persistentvolumeclaim"
"k8s.io/kubernetes/pkg/runtime"
)
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work against persistent volume claims.
@ -39,14 +39,14 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.PersistentVolumeClaims), &api.PersistentVolumeClaim{}, prefix, persistentvolumeclaim.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &api.PersistentVolumeClaim{} },
NewListFunc: newListFunc,
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, name)
return registry.NamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.PersistentVolumeClaim).Name, nil
@ -73,7 +73,7 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
// StatusREST implements the REST endpoint for changing the status of a persistentvolumeclaim.
type StatusREST struct {
store *etcdgeneric.Etcd
store *registry.Store
}
func (r *StatusREST) New() runtime.Object {

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

@ -62,7 +62,7 @@ func validNewPersistentVolumeClaim(name, ns string) *api.PersistentVolumeClaim {
func TestCreate(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
pv := validNewPersistentVolumeClaim("foo", api.NamespaceDefault)
pv.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -78,7 +78,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestUpdate(
// valid
validNewPersistentVolumeClaim("foo", api.NamespaceDefault),
@ -98,28 +98,28 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ReturnDeletedObject()
test := registrytest.New(t, storage.Store).ReturnDeletedObject()
test.TestDelete(validNewPersistentVolumeClaim("foo", api.NamespaceDefault))
}
func TestGet(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestGet(validNewPersistentVolumeClaim("foo", api.NamespaceDefault))
}
func TestList(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestList(validNewPersistentVolumeClaim("foo", api.NamespaceDefault))
}
func TestWatch(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestWatch(
validNewPersistentVolumeClaim("foo", api.NamespaceDefault),
// matching labels

12
pkg/registry/petset/etcd/etcd.go
View File

@ -23,14 +23,14 @@ import (
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/registry/petset"
"k8s.io/kubernetes/pkg/runtime"
)
// rest implements a RESTStorage for replication controllers against etcd
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work against replication controllers.
@ -41,7 +41,7 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.PetSet), &appsapi.PetSet{}, prefix, petset.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &appsapi.PetSet{} },
// NewListFunc returns an object capable of storing results of an etcd list.
@ -49,12 +49,12 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
// Produces a petSet that etcd understands, to the root of the resource
// by combining the namespace in the context with the given prefix
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
// Produces a petSet that etcd understands, to the resource by combining
// the namespace in the context with the given prefix
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, name)
return registry.NamespaceKeyFunc(ctx, prefix, name)
},
// Retrieve the name field of a replication controller
ObjectNameFunc: func(obj runtime.Object) (string, error) {
@ -83,7 +83,7 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
// StatusREST implements the REST endpoint for changing the status of an petSet
type StatusREST struct {
store *etcdgeneric.Etcd
store *registry.Store
}
func (r *StatusREST) New() runtime.Object {

10
pkg/registry/petset/etcd/etcd_test.go
View File

@ -82,7 +82,7 @@ func validNewPetSet() *apps.PetSet {
func TestCreate(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
ps := validNewPetSet()
ps.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -134,28 +134,28 @@ func TestStatusUpdate(t *testing.T) {
func TestGet(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestGet(validNewPetSet())
}
func TestList(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestList(validNewPetSet())
}
func TestDelete(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestDelete(validNewPetSet())
}
func TestWatch(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestWatch(
validNewPetSet(),
// matching labels

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

@ -32,7 +32,7 @@ import (
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/registry/pod"
podrest "k8s.io/kubernetes/pkg/registry/pod/rest"
"k8s.io/kubernetes/pkg/runtime"
@ -53,7 +53,7 @@ type PodStorage struct {
// REST implements a RESTStorage for pods against etcd
type REST struct {
*etcdgeneric.Etcd
*registry.Store
proxyTransport http.RoundTripper
}
@ -65,14 +65,14 @@ func NewStorage(opts generic.RESTOptions, k client.ConnectionInfoGetter, proxyTr
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Pods), &api.Pod{}, prefix, pod.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &api.Pod{} },
NewListFunc: newListFunc,
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, name)
return registry.NamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.Pod).Name, nil
@ -116,7 +116,7 @@ func (r *REST) ResourceLocation(ctx api.Context, name string) (*url.URL, http.Ro
// BindingREST implements the REST endpoint for binding pods to nodes when etcd is in use.
type BindingREST struct {
store *etcdgeneric.Etcd
store *registry.Store
}
// New creates a new binding resource
@ -186,7 +186,7 @@ func (r *BindingREST) assignPod(ctx api.Context, podID string, machine string, a
// StatusREST implements the REST endpoint for changing the status of a pod.
type StatusREST struct {
store *etcdgeneric.Etcd
store *registry.Store
}
// New creates a new pod resource

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

@ -82,7 +82,7 @@ func validChangedPod() *api.Pod {
func TestCreate(t *testing.T) {
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
pod := validNewPod()
pod.ObjectMeta = api.ObjectMeta{}
// Make an invalid pod with an an incorrect label.
@ -108,7 +108,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestUpdate(
// valid
validNewPod(),
@ -124,7 +124,7 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ReturnDeletedObject()
test := registrytest.New(t, storage.Store).ReturnDeletedObject()
test.TestDelete(validNewPod())
scheduledPod := validNewPod()
@ -341,21 +341,21 @@ func TestResourceLocation(t *testing.T) {
func TestGet(t *testing.T) {
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestGet(validNewPod())
}
func TestList(t *testing.T) {
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestList(validNewPod())
}
func TestWatch(t *testing.T) {
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestWatch(
validNewPod(),
// matching labels

4
pkg/registry/pod/rest/log.go
View File

@ -24,7 +24,7 @@ import (
"k8s.io/kubernetes/pkg/api/rest"
"k8s.io/kubernetes/pkg/api/validation"
"k8s.io/kubernetes/pkg/kubelet/client"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
genericrest "k8s.io/kubernetes/pkg/registry/generic/rest"
"k8s.io/kubernetes/pkg/registry/pod"
"k8s.io/kubernetes/pkg/runtime"
@ -33,7 +33,7 @@ import (
// LogREST implements the log endpoint for a Pod
type LogREST struct {
KubeletConn client.ConnectionInfoGetter
Store *etcdgeneric.Etcd
Store *registry.Store
}
// LogREST implements GetterWithOptions

4
pkg/registry/pod/rest/log_test.go
View File

@ -21,13 +21,13 @@ import (
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/errors"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/registry/registrytest"
)
func TestPodLogValidates(t *testing.T) {
etcdStorage, _ := registrytest.NewEtcdStorage(t, "")
store := &etcdgeneric.Etcd{
store := &registry.Store{
Storage: etcdStorage,
}
logRest := &LogREST{Store: store, KubeletConn: nil}

10
pkg/registry/pod/rest/subresources.go
View File

@ -26,7 +26,7 @@ import (
"k8s.io/kubernetes/pkg/api/rest"
"k8s.io/kubernetes/pkg/capabilities"
"k8s.io/kubernetes/pkg/kubelet/client"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
genericrest "k8s.io/kubernetes/pkg/registry/generic/rest"
"k8s.io/kubernetes/pkg/registry/pod"
"k8s.io/kubernetes/pkg/runtime"
@ -34,7 +34,7 @@ import (
// ProxyREST implements the proxy subresource for a Pod
type ProxyREST struct {
Store *etcdgeneric.Etcd
Store *registry.Store
ProxyTransport http.RoundTripper
}
@ -78,7 +78,7 @@ var upgradeableMethods = []string{"GET", "POST"}
// AttachREST implements the attach subresource for a Pod
type AttachREST struct {
Store *etcdgeneric.Etcd
Store *registry.Store
KubeletConn client.ConnectionInfoGetter
}
@ -115,7 +115,7 @@ func (r *AttachREST) ConnectMethods() []string {
// ExecREST implements the exec subresource for a Pod
type ExecREST struct {
Store *etcdgeneric.Etcd
Store *registry.Store
KubeletConn client.ConnectionInfoGetter
}
@ -152,7 +152,7 @@ func (r *ExecREST) ConnectMethods() []string {
// PortForwardREST implements the portforward subresource for a Pod
type PortForwardREST struct {
Store *etcdgeneric.Etcd
Store *registry.Store
KubeletConn client.ConnectionInfoGetter
}

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

@ -22,14 +22,14 @@ import (
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/registry/podsecuritypolicy"
"k8s.io/kubernetes/pkg/runtime"
)
// REST implements a RESTStorage for PodSecurityPolicies against etcd.
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
const Prefix = "/podsecuritypolicies"
@ -40,14 +40,14 @@ func NewREST(opts generic.RESTOptions) *REST {
storageInterface := opts.Decorator(
opts.Storage, 100, &extensions.PodSecurityPolicy{}, Prefix, podsecuritypolicy.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &extensions.PodSecurityPolicy{} },
NewListFunc: newListFunc,
KeyRootFunc: func(ctx api.Context) string {
return Prefix
},
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NoNamespaceKeyFunc(ctx, Prefix, name)
return registry.NoNamespaceKeyFunc(ctx, Prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*extensions.PodSecurityPolicy).Name, nil

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

@ -56,7 +56,7 @@ func validNewPodSecurityPolicy() *extensions.PodSecurityPolicy {
func TestCreate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
scc := validNewPodSecurityPolicy()
scc.ObjectMeta = api.ObjectMeta{GenerateName: "foo-"}
test.TestCreate(
@ -72,7 +72,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
test.TestUpdate(
// valid
validNewPodSecurityPolicy(),
@ -88,28 +88,28 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope().ReturnDeletedObject()
test := registrytest.New(t, storage.Store).ClusterScope().ReturnDeletedObject()
test.TestDelete(validNewPodSecurityPolicy())
}
func TestGet(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
test.TestGet(validNewPodSecurityPolicy())
}
func TestList(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
test.TestList(validNewPodSecurityPolicy())
}
func TestWatch(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ClusterScope()
test := registrytest.New(t, storage.Store).ClusterScope()
test.TestWatch(
validNewPodSecurityPolicy(),
// matching labels

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

@ -22,13 +22,13 @@ import (
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/registry/podtemplate"
"k8s.io/kubernetes/pkg/runtime"
)
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work against pod templates.
@ -39,14 +39,14 @@ func NewREST(opts generic.RESTOptions) *REST {
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.PodTemplates), &api.PodTemplate{}, prefix, podtemplate.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &api.PodTemplate{} },
NewListFunc: newListFunc,
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, name)
return registry.NamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.PodTemplate).Name, nil

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

@ -64,7 +64,7 @@ func validNewPodTemplate(name string) *api.PodTemplate {
func TestCreate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
pod := validNewPodTemplate("foo")
pod.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -80,7 +80,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestUpdate(
//valid
validNewPodTemplate("foo"),
@ -96,28 +96,28 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ReturnDeletedObject()
test := registrytest.New(t, storage.Store).ReturnDeletedObject()
test.TestDelete(validNewPodTemplate("foo"))
}
func TestGet(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestGet(validNewPodTemplate("foo"))
}
func TestList(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestList(validNewPodTemplate("foo"))
}
func TestWatch(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestWatch(
validNewPodTemplate("foo"),
// matching labels

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

@ -27,7 +27,7 @@ import (
"k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/storage"
etcdstorage "k8s.io/kubernetes/pkg/storage/etcd"
@ -44,11 +44,11 @@ func NewEtcdStorage(t *testing.T, group string) (storage.Interface, *etcdtesting
type Tester struct {
tester *resttest.Tester
storage *etcdgeneric.Etcd
storage *registry.Store
}
type UpdateFunc func(runtime.Object) runtime.Object
func New(t *testing.T, storage *etcdgeneric.Etcd) *Tester {
func New(t *testing.T, storage *registry.Store) *Tester {
return &Tester{
tester: resttest.New(t, storage),
storage: storage,

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

@ -30,7 +30,7 @@ import (
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/registry/replicaset"
"k8s.io/kubernetes/pkg/runtime"
)
@ -54,7 +54,7 @@ func NewStorage(opts generic.RESTOptions) ReplicaSetStorage {
}
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work against ReplicaSet.
@ -65,7 +65,7 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Replicasets), &extensions.ReplicaSet{}, prefix, replicaset.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &extensions.ReplicaSet{} },
// NewListFunc returns an object capable of storing results of an etcd list.
@ -73,12 +73,12 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
// Produces a path that etcd understands, to the root of the resource
// by combining the namespace in the context with the given prefix
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
// Produces a path that etcd understands, to the resource by combining
// the namespace in the context with the given prefix
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, name)
return registry.NamespaceKeyFunc(ctx, prefix, name)
},
// Retrieve the name field of a ReplicaSet
ObjectNameFunc: func(obj runtime.Object) (string, error) {
@ -108,7 +108,7 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
// StatusREST implements the REST endpoint for changing the status of a ReplicaSet
type StatusREST struct {
store *etcdgeneric.Etcd
store *registry.Store
}
func (r *StatusREST) New() runtime.Object {

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

@ -90,7 +90,7 @@ var validReplicaSet = *validNewReplicaSet()
func TestCreate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.ReplicaSet.Etcd)
test := registrytest.New(t, storage.ReplicaSet.Store)
rs := validNewReplicaSet()
rs.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -110,7 +110,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.ReplicaSet.Etcd)
test := registrytest.New(t, storage.ReplicaSet.Store)
test.TestUpdate(
// valid
validNewReplicaSet(),
@ -137,7 +137,7 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.ReplicaSet.Etcd)
test := registrytest.New(t, storage.ReplicaSet.Store)
test.TestDelete(validNewReplicaSet())
}
@ -194,21 +194,21 @@ func TestGenerationNumber(t *testing.T) {
func TestGet(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.ReplicaSet.Etcd)
test := registrytest.New(t, storage.ReplicaSet.Store)
test.TestGet(validNewReplicaSet())
}
func TestList(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.ReplicaSet.Etcd)
test := registrytest.New(t, storage.ReplicaSet.Store)
test.TestList(validNewReplicaSet())
}
func TestWatch(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.ReplicaSet.Etcd)
test := registrytest.New(t, storage.ReplicaSet.Store)
test.TestWatch(
validNewReplicaSet(),
// matching labels

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

@ -22,13 +22,13 @@ import (
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/registry/resourcequota"
"k8s.io/kubernetes/pkg/runtime"
)
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work against resource quotas.
@ -39,14 +39,14 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.ResourceQuotas), &api.ResourceQuota{}, prefix, resourcequota.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &api.ResourceQuota{} },
NewListFunc: newListFunc,
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, name)
return registry.NamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.ResourceQuota).Name, nil
@ -73,7 +73,7 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
// StatusREST implements the REST endpoint for changing the status of a resourcequota.
type StatusREST struct {
store *etcdgeneric.Etcd
store *registry.Store
}
func (r *StatusREST) New() runtime.Object {

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

@ -59,7 +59,7 @@ func validNewResourceQuota() *api.ResourceQuota {
func TestCreate(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
resourcequota := validNewResourceQuota()
resourcequota.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -98,28 +98,28 @@ func TestCreateSetsFields(t *testing.T) {
func TestDelete(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ReturnDeletedObject()
test := registrytest.New(t, storage.Store).ReturnDeletedObject()
test.TestDelete(validNewResourceQuota())
}
func TestGet(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestGet(validNewResourceQuota())
}
func TestList(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestList(validNewResourceQuota())
}
func TestWatch(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestWatch(
validNewResourceQuota(),
// matching labels

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

@ -22,13 +22,13 @@ import (
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/registry/secret"
"k8s.io/kubernetes/pkg/runtime"
)
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work against secrets.
@ -39,14 +39,14 @@ func NewREST(opts generic.RESTOptions) *REST {
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Secrets), &api.Secret{}, prefix, secret.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &api.Secret{} },
NewListFunc: newListFunc,
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
KeyFunc: func(ctx api.Context, id string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, id)
return registry.NamespaceKeyFunc(ctx, prefix, id)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.Secret).Name, nil

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

@ -49,7 +49,7 @@ func validNewSecret(name string) *api.Secret {
func TestCreate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
secret := validNewSecret("foo")
secret.ObjectMeta = api.ObjectMeta{GenerateName: "foo-"}
test.TestCreate(
@ -71,7 +71,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestUpdate(
// valid
validNewSecret("foo"),
@ -87,28 +87,28 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestDelete(validNewSecret("foo"))
}
func TestGet(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestGet(validNewSecret("foo"))
}
func TestList(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestList(validNewSecret("foo"))
}
func TestWatch(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestWatch(
validNewSecret("foo"),
// matching labels

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

@ -22,13 +22,13 @@ import (
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/registry/service"
"k8s.io/kubernetes/pkg/runtime"
)
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work against services.
@ -39,14 +39,14 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Services), &api.Service{}, prefix, service.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &api.Service{} },
NewListFunc: newListFunc,
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, name)
return registry.NamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.Service).Name, nil
@ -71,7 +71,7 @@ func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) {
// StatusREST implements the REST endpoint for changing the status of a service.
type StatusREST struct {
store *etcdgeneric.Etcd
store *registry.Store
}
func (r *StatusREST) New() runtime.Object {

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

@ -59,7 +59,7 @@ func validService() *api.Service {
func TestCreate(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
validService := validService()
validService.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -89,7 +89,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate()
test := registrytest.New(t, storage.Store).AllowCreateOnUpdate()
test.TestUpdate(
// valid
validService(),
@ -114,28 +114,28 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate()
test := registrytest.New(t, storage.Store).AllowCreateOnUpdate()
test.TestDelete(validService())
}
func TestGet(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate()
test := registrytest.New(t, storage.Store).AllowCreateOnUpdate()
test.TestGet(validService())
}
func TestList(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).AllowCreateOnUpdate()
test := registrytest.New(t, storage.Store).AllowCreateOnUpdate()
test.TestList(validService())
}
func TestWatch(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestWatch(
validService(),
// matching labels

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

@ -22,13 +22,13 @@ import (
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/cachesize"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/registry/serviceaccount"
"k8s.io/kubernetes/pkg/runtime"
)
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a RESTStorage object that will work against service accounts.
@ -39,14 +39,14 @@ func NewREST(opts generic.RESTOptions) *REST {
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.ServiceAccounts), &api.ServiceAccount{}, prefix, serviceaccount.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &api.ServiceAccount{} },
NewListFunc: newListFunc,
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, name)
return registry.NamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.ServiceAccount).Name, nil

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

@ -47,7 +47,7 @@ func validNewServiceAccount(name string) *api.ServiceAccount {
func TestCreate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
serviceAccount := validNewServiceAccount("foo")
serviceAccount.ObjectMeta = api.ObjectMeta{GenerateName: "foo-"}
test.TestCreate(
@ -64,7 +64,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestUpdate(
// valid
validNewServiceAccount("foo"),
@ -80,28 +80,28 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd).ReturnDeletedObject()
test := registrytest.New(t, storage.Store).ReturnDeletedObject()
test.TestDelete(validNewServiceAccount("foo"))
}
func TestGet(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestGet(validNewServiceAccount("foo"))
}
func TestList(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestList(validNewServiceAccount("foo"))
}
func TestWatch(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestWatch(
validNewServiceAccount("foo"),
// matching labels

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

@ -22,14 +22,14 @@ import (
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/registry/thirdpartyresource"
"k8s.io/kubernetes/pkg/runtime"
)
// REST implements a RESTStorage for ThirdPartyResources against etcd
type REST struct {
*etcdgeneric.Etcd
*registry.Store
}
// NewREST returns a registry which will store ThirdPartyResource in the given helper
@ -39,14 +39,14 @@ func NewREST(opts generic.RESTOptions) *REST {
// We explicitly do NOT do any decoration here yet.
storageInterface := opts.Storage
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &extensions.ThirdPartyResource{} },
NewListFunc: func() runtime.Object { return &extensions.ThirdPartyResourceList{} },
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
KeyFunc: func(ctx api.Context, id string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, id)
return registry.NamespaceKeyFunc(ctx, prefix, id)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*extensions.ThirdPartyResource).Name, nil

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

@ -54,7 +54,7 @@ func validNewThirdPartyResource(name string) *extensions.ThirdPartyResource {
func TestCreate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
rsrc := validNewThirdPartyResource("foo")
rsrc.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -68,7 +68,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestUpdate(
// valid
validNewThirdPartyResource("foo"),
@ -84,28 +84,28 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestDelete(validNewThirdPartyResource("foo"))
}
func TestGet(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestGet(validNewThirdPartyResource("foo"))
}
func TestList(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestList(validNewThirdPartyResource("foo"))
}
func TestWatch(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestWatch(
validNewThirdPartyResource("foo"),
// matching labels

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

@ -24,14 +24,14 @@ import (
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/labels"
"k8s.io/kubernetes/pkg/registry/generic"
etcdgeneric "k8s.io/kubernetes/pkg/registry/generic/etcd"
"k8s.io/kubernetes/pkg/registry/generic/registry"
"k8s.io/kubernetes/pkg/registry/thirdpartyresourcedata"
"k8s.io/kubernetes/pkg/runtime"
)
// REST implements a RESTStorage for ThirdPartyResourceDatas against etcd
type REST struct {
*etcdgeneric.Etcd
*registry.Store
kind string
}
@ -42,14 +42,14 @@ func NewREST(opts generic.RESTOptions, group, kind string) *REST {
// We explicitly do NOT do any decoration here yet.
storageInterface := opts.Storage
store := &etcdgeneric.Etcd{
store := &registry.Store{
NewFunc: func() runtime.Object { return &extensions.ThirdPartyResourceData{} },
NewListFunc: func() runtime.Object { return &extensions.ThirdPartyResourceDataList{} },
KeyRootFunc: func(ctx api.Context) string {
return etcdgeneric.NamespaceKeyRootFunc(ctx, prefix)
return registry.NamespaceKeyRootFunc(ctx, prefix)
},
KeyFunc: func(ctx api.Context, id string) (string, error) {
return etcdgeneric.NamespaceKeyFunc(ctx, prefix, id)
return registry.NamespaceKeyFunc(ctx, prefix, id)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*extensions.ThirdPartyResourceData).Name, nil
@ -67,7 +67,7 @@ func NewREST(opts generic.RESTOptions, group, kind string) *REST {
}
return &REST{
Etcd: store,
Store: store,
kind: kind,
}
}

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

@ -50,7 +50,7 @@ func validNewThirdPartyResourceData(name string) *extensions.ThirdPartyResourceD
func TestCreate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
rsrc := validNewThirdPartyResourceData("foo")
rsrc.ObjectMeta = api.ObjectMeta{}
test.TestCreate(
@ -64,7 +64,7 @@ func TestCreate(t *testing.T) {
func TestUpdate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestUpdate(
// valid
validNewThirdPartyResourceData("foo"),
@ -80,28 +80,28 @@ func TestUpdate(t *testing.T) {
func TestDelete(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestDelete(validNewThirdPartyResourceData("foo"))
}
func TestGet(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestGet(validNewThirdPartyResourceData("foo"))
}
func TestList(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestList(validNewThirdPartyResourceData("foo"))
}
func TestWatch(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
test := registrytest.New(t, storage.Etcd)
test := registrytest.New(t, storage.Store)
test.TestWatch(
validNewThirdPartyResourceData("foo"),
// matching labels