Remove deletecollection support from namespace object

pkg/registry/core/namespace/storage/BUILD

@@ -34,8 +34,10 @@ go_library(
         "//pkg/registry/cachesize:go_default_library",
         "//pkg/registry/core/namespace:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/internalversion:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
         "//vendor/k8s.io/apiserver/pkg/endpoints/request:go_default_library",
         "//vendor/k8s.io/apiserver/pkg/registry/generic:go_default_library",
         "//vendor/k8s.io/apiserver/pkg/registry/generic/registry:go_default_library",

pkg/registry/core/namespace/storage/storage.go

@@ -20,8 +20,10 @@ import (
 	"fmt"
 
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	metainternalversion "k8s.io/apimachinery/pkg/apis/meta/internalversion"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/watch"
 	genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
 	"k8s.io/apiserver/pkg/registry/generic"
 	genericregistry "k8s.io/apiserver/pkg/registry/generic/registry"
@@ -35,7 +37,7 @@ import (
 
 // rest implements a RESTStorage for namespaces
 type REST struct {
-	*genericregistry.Store
+	store  *genericregistry.Store
 	status *genericregistry.Store
 }
 
@@ -75,7 +77,39 @@ func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST, *Finaliz
 	finalizeStore := *store
 	finalizeStore.UpdateStrategy = namespace.FinalizeStrategy
 
-	return &REST{Store: store, status: &statusStore}, &StatusREST{store: &statusStore}, &FinalizeREST{store: &finalizeStore}
+	return &REST{store: store, status: &statusStore}, &StatusREST{store: &statusStore}, &FinalizeREST{store: &finalizeStore}
+}
+
+func (r *REST) New() runtime.Object {
+	return r.store.New()
+}
+
+func (r *REST) NewList() runtime.Object {
+	return r.store.NewList()
+}
+
+func (r *REST) List(ctx genericapirequest.Context, options *metainternalversion.ListOptions) (runtime.Object, error) {
+	return r.store.List(ctx, options)
+}
+
+func (r *REST) Create(ctx genericapirequest.Context, obj runtime.Object) (runtime.Object, error) {
+	return r.store.Create(ctx, obj)
+}
+
+func (r *REST) Update(ctx genericapirequest.Context, name string, objInfo rest.UpdatedObjectInfo) (runtime.Object, bool, error) {
+	return r.store.Update(ctx, name, objInfo)
+}
+
+func (r *REST) Get(ctx genericapirequest.Context, name string, options *metav1.GetOptions) (runtime.Object, error) {
+	return r.store.Get(ctx, name, options)
+}
+
+func (r *REST) Watch(ctx genericapirequest.Context, options *metainternalversion.ListOptions) (watch.Interface, error) {
+	return r.store.Watch(ctx, options)
+}
+
+func (r *REST) Export(ctx genericapirequest.Context, name string, opts metav1.ExportOptions) (runtime.Object, error) {
+	return r.store.Export(ctx, name, opts)
 }
 
 // Delete enforces life-cycle rules for namespace termination
@@ -108,15 +142,15 @@ func (r *REST) Delete(ctx genericapirequest.Context, name string, options *metav
 	// upon first request to delete, we switch the phase to start namespace termination
 	// TODO: enhance graceful deletion's calls to DeleteStrategy to allow phase change and finalizer patterns
 	if namespace.DeletionTimestamp.IsZero() {
-		key, err := r.Store.KeyFunc(ctx, name)
+		key, err := r.store.KeyFunc(ctx, name)
 		if err != nil {
 			return nil, false, err
 		}
 
 		preconditions := storage.Preconditions{UID: options.Preconditions.UID}
 
-		out := r.Store.NewFunc()
+		out := r.store.NewFunc()
-		err = r.Store.Storage.GuaranteedUpdate(
+		err = r.store.Storage.GuaranteedUpdate(
 			ctx, key, out, false, &preconditions,
 			storage.SimpleUpdate(func(existing runtime.Object) (runtime.Object, error) {
 				existingNamespace, ok := existing.(*api.Namespace)
@@ -167,7 +201,7 @@ func (r *REST) Delete(ctx genericapirequest.Context, name string, options *metav
 		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, false, err
 	}
-	return r.Store.Delete(ctx, name, options)
+	return r.store.Delete(ctx, name, options)
 }
 
 // Implement ShortNamesProvider

pkg/registry/core/namespace/storage/storage_test.go

@@ -47,8 +47,8 @@ func validNewNamespace() *api.Namespace {
 func TestCreate(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
-	defer storage.Store.DestroyFunc()
+	defer storage.store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.store).ClusterScope()
 	namespace := validNewNamespace()
 	namespace.ObjectMeta = metav1.ObjectMeta{GenerateName: "foo"}
 	test.TestCreate(
@@ -64,7 +64,7 @@ func TestCreate(t *testing.T) {
 func TestCreateSetsFields(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
-	defer storage.Store.DestroyFunc()
+	defer storage.store.DestroyFunc()
 	namespace := validNewNamespace()
 	ctx := genericapirequest.NewContext()
 	_, err := storage.Create(ctx, namespace)
@@ -91,32 +91,32 @@ func TestCreateSetsFields(t *testing.T) {
 func TestDelete(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
-	defer storage.Store.DestroyFunc()
+	defer storage.store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).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)
-	defer storage.Store.DestroyFunc()
+	defer storage.store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.store).ClusterScope()
 	test.TestGet(validNewNamespace())
 }
 
 func TestList(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
-	defer storage.Store.DestroyFunc()
+	defer storage.store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.store).ClusterScope()
 	test.TestList(validNewNamespace())
 }
 
 func TestWatch(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
-	defer storage.Store.DestroyFunc()
+	defer storage.store.DestroyFunc()
-	test := registrytest.New(t, storage.Store).ClusterScope()
+	test := registrytest.New(t, storage.store).ClusterScope()
 	test.TestWatch(
 		validNewNamespace(),
 		// matching labels
@@ -140,7 +140,7 @@ func TestWatch(t *testing.T) {
 func TestDeleteNamespaceWithIncompleteFinalizers(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
-	defer storage.Store.DestroyFunc()
+	defer storage.store.DestroyFunc()
 	key := "namespaces/foo"
 	ctx := genericapirequest.NewContext()
 	now := metav1.Now()
@@ -154,7 +154,7 @@ func TestDeleteNamespaceWithIncompleteFinalizers(t *testing.T) {
 		},
 		Status: api.NamespaceStatus{Phase: api.NamespaceActive},
 	}
-	if err := storage.Storage.Create(ctx, key, namespace, nil, 0); err != nil {
+	if err := storage.store.Storage.Create(ctx, key, namespace, nil, 0); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 	if _, _, err := storage.Delete(ctx, "foo", nil); err == nil {
@@ -165,7 +165,7 @@ func TestDeleteNamespaceWithIncompleteFinalizers(t *testing.T) {
 func TestDeleteNamespaceWithCompleteFinalizers(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
-	defer storage.Store.DestroyFunc()
+	defer storage.store.DestroyFunc()
 	key := "namespaces/foo"
 	ctx := genericapirequest.NewContext()
 	now := metav1.Now()
@@ -179,7 +179,7 @@ func TestDeleteNamespaceWithCompleteFinalizers(t *testing.T) {
 		},
 		Status: api.NamespaceStatus{Phase: api.NamespaceActive},
 	}
-	if err := storage.Storage.Create(ctx, key, namespace, nil, 0); err != nil {
+	if err := storage.store.Storage.Create(ctx, key, namespace, nil, 0); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 	if _, _, err := storage.Delete(ctx, "foo", nil); err != nil {
@@ -190,7 +190,7 @@ func TestDeleteNamespaceWithCompleteFinalizers(t *testing.T) {
 func TestShortNames(t *testing.T) {
 	storage, server := newStorage(t)
 	defer server.Terminate(t)
-	defer storage.Store.DestroyFunc()
+	defer storage.store.DestroyFunc()
 	expected := []string{"ns"}
 	registrytest.AssertShortNames(t, storage, expected)
 }