Merge pull request #108169 from deads2k/fix-rest-handlers

convert rest storage to per-resource part 1 of...?

pkg/registry/admissionregistration/rest/storage_apiserver.go

@@ -35,33 +35,36 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag
 	// If you add a version here, be sure to add an entry in `k8s.io/kubernetes/cmd/kube-apiserver/app/aggregator.go with specific priorities.
 	// TODO refactor the plumbing to provide the information in the APIGroupInfo
 
-	if apiResourceConfigSource.VersionEnabled(admissionregistrationv1.SchemeGroupVersion) {
 	if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
 		return genericapiserver.APIGroupInfo{}, false, err
-		} else {
+	} else if len(storageMap) > 0 {
 		apiGroupInfo.VersionedResourcesStorageMap[admissionregistrationv1.SchemeGroupVersion.Version] = storageMap
 	}
-	}
 	return apiGroupInfo, true, nil
 }
 
 func (p RESTStorageProvider) v1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
+
 	// validatingwebhookconfigurations
+	if resource := "validatingwebhookconfigurations"; apiResourceConfigSource.ResourceEnabled(admissionregistrationv1.SchemeGroupVersion.WithResource(resource)) {
 		validatingStorage, err := validatingwebhookconfigurationstorage.NewREST(restOptionsGetter)
 		if err != nil {
 			return storage, err
 		}
-	storage["validatingwebhookconfigurations"] = validatingStorage
+		storage[resource] = validatingStorage
+	}
 
 	// mutatingwebhookconfigurations
+	if resource := "mutatingwebhookconfigurations"; apiResourceConfigSource.ResourceEnabled(admissionregistrationv1.SchemeGroupVersion.WithResource(resource)) {
 		mutatingStorage, err := mutatingwebhookconfigurationstorage.NewREST(restOptionsGetter)
 		if err != nil {
 			return storage, err
 		}
-	storage["mutatingwebhookconfigurations"] = mutatingStorage
+		storage[resource] = mutatingStorage
+	}
 
-	return storage, err
+	return storage, nil
 }
 
 func (p RESTStorageProvider) GroupName() string {

pkg/registry/apiserverinternal/rest/storage.go

@@ -34,24 +34,26 @@ type StorageProvider struct{}
 func (p StorageProvider) NewRESTStorage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (genericapiserver.APIGroupInfo, bool, error) {
 	apiGroupInfo := genericapiserver.NewDefaultAPIGroupInfo(apiserverinternal.GroupName, legacyscheme.Scheme, legacyscheme.ParameterCodec, legacyscheme.Codecs)
 
-	if apiResourceConfigSource.VersionEnabled(apiserverv1alpha1.SchemeGroupVersion) {
+	if storageMap, err := p.v1alpha1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
-		storageMap, err := p.v1alpha1Storage(apiResourceConfigSource, restOptionsGetter)
-		if err != nil {
 		return genericapiserver.APIGroupInfo{}, false, err
-		}
+	} else if len(storageMap) > 0 {
 		apiGroupInfo.VersionedResourcesStorageMap[apiserverv1alpha1.SchemeGroupVersion.Version] = storageMap
 	}
+
 	return apiGroupInfo, true, nil
 }
 
 func (p StorageProvider) v1alpha1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
+
+	if resource := "storageversions"; apiResourceConfigSource.ResourceEnabled(apiserverv1alpha1.SchemeGroupVersion.WithResource(resource)) {
 		s, status, err := storageversionstorage.NewREST(restOptionsGetter)
 		if err != nil {
 			return nil, err
 		}
-	storage["storageversions"] = s
+		storage[resource] = s
-	storage["storageversions/status"] = status
+		storage[resource+"/status"] = status
+	}
 
 	return storage, nil
 }

pkg/registry/apps/rest/storage_apps.go

@@ -40,11 +40,9 @@ func (p StorageProvider) NewRESTStorage(apiResourceConfigSource serverstorage.AP
 	// If you add a version here, be sure to add an entry in `k8s.io/kubernetes/cmd/kube-apiserver/app/aggregator.go with specific priorities.
 	// TODO refactor the plumbing to provide the information in the APIGroupInfo
 
-	if apiResourceConfigSource.VersionEnabled(appsapiv1.SchemeGroupVersion) {
+	if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
-		storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter)
-		if err != nil {
 		return genericapiserver.APIGroupInfo{}, false, err
-		}
+	} else if len(storageMap) > 0 {
 		apiGroupInfo.VersionedResourcesStorageMap[appsapiv1.SchemeGroupVersion.Version] = storageMap
 	}
 
@@ -55,46 +53,56 @@ func (p StorageProvider) v1Storage(apiResourceConfigSource serverstorage.APIReso
 	storage := map[string]rest.Storage{}
 
 	// deployments
+	if resource := "deployments"; apiResourceConfigSource.ResourceEnabled(appsapiv1.SchemeGroupVersion.WithResource(resource)) {
 		deploymentStorage, err := deploymentstore.NewStorage(restOptionsGetter)
 		if err != nil {
 			return storage, err
 		}
-	storage["deployments"] = deploymentStorage.Deployment
+		storage[resource] = deploymentStorage.Deployment
-	storage["deployments/status"] = deploymentStorage.Status
+		storage[resource+"/status"] = deploymentStorage.Status
-	storage["deployments/scale"] = deploymentStorage.Scale
+		storage[resource+"/scale"] = deploymentStorage.Scale
+	}
 
 	// statefulsets
+	if resource := "statefulsets"; apiResourceConfigSource.ResourceEnabled(appsapiv1.SchemeGroupVersion.WithResource(resource)) {
 		statefulSetStorage, err := statefulsetstore.NewStorage(restOptionsGetter)
 		if err != nil {
 			return storage, err
 		}
-	storage["statefulsets"] = statefulSetStorage.StatefulSet
+		storage[resource] = statefulSetStorage.StatefulSet
-	storage["statefulsets/status"] = statefulSetStorage.Status
+		storage[resource+"/status"] = statefulSetStorage.Status
-	storage["statefulsets/scale"] = statefulSetStorage.Scale
+		storage[resource+"/scale"] = statefulSetStorage.Scale
+	}
 
 	// daemonsets
+	if resource := "daemonsets"; apiResourceConfigSource.ResourceEnabled(appsapiv1.SchemeGroupVersion.WithResource(resource)) {
 		daemonSetStorage, daemonSetStatusStorage, err := daemonsetstore.NewREST(restOptionsGetter)
 		if err != nil {
 			return storage, err
 		}
-	storage["daemonsets"] = daemonSetStorage
+		storage[resource] = daemonSetStorage
-	storage["daemonsets/status"] = daemonSetStatusStorage
+		storage[resource+"/status"] = daemonSetStatusStorage
+	}
 
 	// replicasets
+	if resource := "replicasets"; apiResourceConfigSource.ResourceEnabled(appsapiv1.SchemeGroupVersion.WithResource(resource)) {
 		replicaSetStorage, err := replicasetstore.NewStorage(restOptionsGetter)
 		if err != nil {
 			return storage, err
 		}
-	storage["replicasets"] = replicaSetStorage.ReplicaSet
+		storage[resource] = replicaSetStorage.ReplicaSet
-	storage["replicasets/status"] = replicaSetStorage.Status
+		storage[resource+"/status"] = replicaSetStorage.Status
-	storage["replicasets/scale"] = replicaSetStorage.Scale
+		storage[resource+"/scale"] = replicaSetStorage.Scale
+	}
 
 	// controllerrevisions
+	if resource := "controllerrevisions"; apiResourceConfigSource.ResourceEnabled(appsapiv1.SchemeGroupVersion.WithResource(resource)) {
 		historyStorage, err := controllerrevisionsstore.NewREST(restOptionsGetter)
 		if err != nil {
 			return storage, err
 		}
-	storage["controllerrevisions"] = historyStorage
+		storage[resource] = historyStorage
+	}
 
 	return storage, nil
 }

pkg/registry/authentication/rest/storage_authentication.go

@@ -43,8 +43,8 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag
 	// If you add a version here, be sure to add an entry in `k8s.io/kubernetes/cmd/kube-apiserver/app/aggregator.go with specific priorities.
 	// TODO refactor the plumbing to provide the information in the APIGroupInfo
 
-	if apiResourceConfigSource.VersionEnabled(authenticationv1.SchemeGroupVersion) {
+	if storageMap := p.v1Storage(apiResourceConfigSource, restOptionsGetter); len(storageMap) > 0 {
-		apiGroupInfo.VersionedResourcesStorageMap[authenticationv1.SchemeGroupVersion.Version] = p.v1Storage(apiResourceConfigSource, restOptionsGetter)
+		apiGroupInfo.VersionedResourcesStorageMap[authenticationv1.SchemeGroupVersion.Version] = storageMap
 	}
 
 	return apiGroupInfo, true, nil
@@ -52,9 +52,12 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag
 
 func (p RESTStorageProvider) v1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) map[string]rest.Storage {
 	storage := map[string]rest.Storage{}
+
 	// tokenreviews
+	if resource := "tokenreviews"; apiResourceConfigSource.ResourceEnabled(authenticationv1.SchemeGroupVersion.WithResource(resource)) {
 		tokenReviewStorage := tokenreview.NewREST(p.Authenticator, p.APIAudiences)
-	storage["tokenreviews"] = tokenReviewStorage
+		storage[resource] = tokenReviewStorage
+	}
 
 	return storage
 }

pkg/registry/authorization/rest/storage_authorization.go

@@ -45,8 +45,8 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag
 	// If you add a version here, be sure to add an entry in `k8s.io/kubernetes/cmd/kube-apiserver/app/aggregator.go with specific priorities.
 	// TODO refactor the plumbing to provide the information in the APIGroupInfo
 
-	if apiResourceConfigSource.VersionEnabled(authorizationv1.SchemeGroupVersion) {
+	if storageMap := p.v1Storage(apiResourceConfigSource, restOptionsGetter); len(storageMap) > 0 {
-		apiGroupInfo.VersionedResourcesStorageMap[authorizationv1.SchemeGroupVersion.Version] = p.v1Storage(apiResourceConfigSource, restOptionsGetter)
+		apiGroupInfo.VersionedResourcesStorageMap[authorizationv1.SchemeGroupVersion.Version] = storageMap
 	}
 
 	return apiGroupInfo, true, nil
@@ -54,14 +54,26 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag
 
 func (p RESTStorageProvider) v1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) map[string]rest.Storage {
 	storage := map[string]rest.Storage{}
+
 	// subjectaccessreviews
-	storage["subjectaccessreviews"] = subjectaccessreview.NewREST(p.Authorizer)
+	if resource := "subjectaccessreviews"; apiResourceConfigSource.ResourceEnabled(authorizationv1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = subjectaccessreview.NewREST(p.Authorizer)
+	}
+
 	// selfsubjectaccessreviews
-	storage["selfsubjectaccessreviews"] = selfsubjectaccessreview.NewREST(p.Authorizer)
+	if resource := "selfsubjectaccessreviews"; apiResourceConfigSource.ResourceEnabled(authorizationv1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = selfsubjectaccessreview.NewREST(p.Authorizer)
+	}
+
 	// localsubjectaccessreviews
-	storage["localsubjectaccessreviews"] = localsubjectaccessreview.NewREST(p.Authorizer)
+	if resource := "localsubjectaccessreviews"; apiResourceConfigSource.ResourceEnabled(authorizationv1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = localsubjectaccessreview.NewREST(p.Authorizer)
+	}
+
 	// selfsubjectrulesreviews
-	storage["selfsubjectrulesreviews"] = selfsubjectrulesreview.NewREST(p.RuleResolver)
+	if resource := "selfsubjectrulesreviews"; apiResourceConfigSource.ResourceEnabled(authorizationv1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = selfsubjectrulesreview.NewREST(p.RuleResolver)
+	}
 
 	return storage
 }

pkg/registry/autoscaling/rest/storage_autoscaling.go

@@ -37,88 +37,94 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag
 	// If you add a version here, be sure to add an entry in `k8s.io/kubernetes/cmd/kube-apiserver/app/aggregator.go with specific priorities.
 	// TODO refactor the plumbing to provide the information in the APIGroupInfo
 
-	if apiResourceConfigSource.VersionEnabled(autoscalingapiv2beta2.SchemeGroupVersion) {
 	if storageMap, err := p.v2beta2Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
 		return genericapiserver.APIGroupInfo{}, false, err
-		} else {
+	} else if len(storageMap) > 0 {
 		apiGroupInfo.VersionedResourcesStorageMap[autoscalingapiv2beta2.SchemeGroupVersion.Version] = storageMap
 	}
-	}
+
-	if apiResourceConfigSource.VersionEnabled(autoscalingapiv2.SchemeGroupVersion) {
 	if storageMap, err := p.v2Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
 		return genericapiserver.APIGroupInfo{}, false, err
-		} else {
+	} else if len(storageMap) > 0 {
 		apiGroupInfo.VersionedResourcesStorageMap[autoscalingapiv2.SchemeGroupVersion.Version] = storageMap
 	}
-	}
+
-	if apiResourceConfigSource.VersionEnabled(autoscalingapiv2beta1.SchemeGroupVersion) {
 	if storageMap, err := p.v2beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
 		return genericapiserver.APIGroupInfo{}, false, err
-		} else {
+	} else if len(storageMap) > 0 {
 		apiGroupInfo.VersionedResourcesStorageMap[autoscalingapiv2beta1.SchemeGroupVersion.Version] = storageMap
 	}
-	}
+
-	if apiResourceConfigSource.VersionEnabled(autoscalingapiv1.SchemeGroupVersion) {
 	if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
 		return genericapiserver.APIGroupInfo{}, false, err
-		} else {
+	} else if len(storageMap) > 0 {
 		apiGroupInfo.VersionedResourcesStorageMap[autoscalingapiv1.SchemeGroupVersion.Version] = storageMap
 	}
-	}
 
 	return apiGroupInfo, true, nil
 }
 
 func (p RESTStorageProvider) v1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
+
 	// horizontalpodautoscalers
+	if resource := "horizontalpodautoscalers"; apiResourceConfigSource.ResourceEnabled(autoscalingapiv1.SchemeGroupVersion.WithResource(resource)) {
 		hpaStorage, hpaStatusStorage, err := horizontalpodautoscalerstore.NewREST(restOptionsGetter)
 		if err != nil {
 			return storage, err
 		}
-	storage["horizontalpodautoscalers"] = hpaStorage
+		storage[resource] = hpaStorage
-	storage["horizontalpodautoscalers/status"] = hpaStatusStorage
+		storage[resource+"/status"] = hpaStatusStorage
+	}
 
-	return storage, err
+	return storage, nil
 }
 
 func (p RESTStorageProvider) v2beta1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
+
 	// horizontalpodautoscalers
+	if resource := "horizontalpodautoscalers"; apiResourceConfigSource.ResourceEnabled(autoscalingapiv2beta1.SchemeGroupVersion.WithResource(resource)) {
 		hpaStorage, hpaStatusStorage, err := horizontalpodautoscalerstore.NewREST(restOptionsGetter)
 		if err != nil {
 			return storage, err
 		}
-	storage["horizontalpodautoscalers"] = hpaStorage
+		storage[resource] = hpaStorage
-	storage["horizontalpodautoscalers/status"] = hpaStatusStorage
+		storage[resource+"/status"] = hpaStatusStorage
+	}
 
-	return storage, err
+	return storage, nil
 }
 
 func (p RESTStorageProvider) v2beta2Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
+
 	// horizontalpodautoscalers
+	if resource := "horizontalpodautoscalers"; apiResourceConfigSource.ResourceEnabled(autoscalingapiv2beta2.SchemeGroupVersion.WithResource(resource)) {
 		hpaStorage, hpaStatusStorage, err := horizontalpodautoscalerstore.NewREST(restOptionsGetter)
 		if err != nil {
 			return storage, err
 		}
-	storage["horizontalpodautoscalers"] = hpaStorage
+		storage[resource] = hpaStorage
-	storage["horizontalpodautoscalers/status"] = hpaStatusStorage
+		storage[resource+"/status"] = hpaStatusStorage
-
+	}
-	return storage, err
+	return storage, nil
 }
 
 func (p RESTStorageProvider) v2Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
+
 	// horizontalpodautoscalers
+	if resource := "horizontalpodautoscalers"; apiResourceConfigSource.ResourceEnabled(autoscalingapiv2.SchemeGroupVersion.WithResource(resource)) {
 		hpaStorage, hpaStatusStorage, err := horizontalpodautoscalerstore.NewREST(restOptionsGetter)
 		if err != nil {
 			return storage, err
 		}
-	storage["horizontalpodautoscalers"] = hpaStorage
+		storage[resource] = hpaStorage
-	storage["horizontalpodautoscalers/status"] = hpaStatusStorage
+		storage[resource+"/status"] = hpaStatusStorage
+	}
 
-	return storage, err
+	return storage, nil
 }
 
 func (p RESTStorageProvider) GroupName() string {

pkg/registry/batch/rest/storage_batch.go

@@ -36,56 +36,60 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag
 	// If you add a version here, be sure to add an entry in `k8s.io/kubernetes/cmd/kube-apiserver/app/aggregator.go with specific priorities.
 	// TODO refactor the plumbing to provide the information in the APIGroupInfo
 
-	if apiResourceConfigSource.VersionEnabled(batchapiv1.SchemeGroupVersion) {
 	if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
 		return genericapiserver.APIGroupInfo{}, false, err
-		} else {
+	} else if len(storageMap) > 0 {
 		apiGroupInfo.VersionedResourcesStorageMap[batchapiv1.SchemeGroupVersion.Version] = storageMap
 	}
-	}
+
-	if apiResourceConfigSource.VersionEnabled(batchapiv1beta1.SchemeGroupVersion) {
 	if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
 		return genericapiserver.APIGroupInfo{}, false, err
-		} else {
+	} else if len(storageMap) > 0 {
 		apiGroupInfo.VersionedResourcesStorageMap[batchapiv1beta1.SchemeGroupVersion.Version] = storageMap
 	}
-	}
 
 	return apiGroupInfo, true, nil
 }
 
 func (p RESTStorageProvider) v1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
+
 	// jobs
+	if resource := "jobs"; apiResourceConfigSource.ResourceEnabled(batchapiv1.SchemeGroupVersion.WithResource(resource)) {
 		jobsStorage, jobsStatusStorage, err := jobstore.NewREST(restOptionsGetter)
 		if err != nil {
 			return storage, err
 		}
-	storage["jobs"] = jobsStorage
+		storage[resource] = jobsStorage
-	storage["jobs/status"] = jobsStatusStorage
+		storage[resource+"/status"] = jobsStatusStorage
+	}
 
 	// cronjobs
+	if resource := "cronjobs"; apiResourceConfigSource.ResourceEnabled(batchapiv1.SchemeGroupVersion.WithResource(resource)) {
 		cronJobsStorage, cronJobsStatusStorage, err := cronjobstore.NewREST(restOptionsGetter)
 		if err != nil {
 			return storage, err
 		}
-	storage["cronjobs"] = cronJobsStorage
+		storage[resource] = cronJobsStorage
-	storage["cronjobs/status"] = cronJobsStatusStorage
+		storage[resource+"/status"] = cronJobsStatusStorage
-
+	}
-	return storage, err
+	return storage, nil
 }
 
 func (p RESTStorageProvider) v1beta1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
+
 	// cronjobs
+	if resource := "cronjobs"; apiResourceConfigSource.ResourceEnabled(batchapiv1beta1.SchemeGroupVersion.WithResource(resource)) {
 		cronJobsStorage, cronJobsStatusStorage, err := cronjobstore.NewREST(restOptionsGetter)
 		if err != nil {
 			return storage, err
 		}
-	storage["cronjobs"] = cronJobsStorage
+		storage[resource] = cronJobsStorage
-	storage["cronjobs/status"] = cronJobsStatusStorage
+		storage[resource+"/status"] = cronJobsStatusStorage
+	}
 
-	return storage, err
+	return storage, nil
 }
 
 func (p RESTStorageProvider) GroupName() string {

pkg/registry/certificates/rest/storage_certificates.go

@@ -34,11 +34,9 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag
 	// If you add a version here, be sure to add an entry in `k8s.io/kubernetes/cmd/kube-apiserver/app/aggregator.go with specific priorities.
 	// TODO refactor the plumbing to provide the information in the APIGroupInfo
 
-	if apiResourceConfigSource.VersionEnabled(certificatesapiv1.SchemeGroupVersion) {
+	if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
-		storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter)
-		if err != nil {
 		return genericapiserver.APIGroupInfo{}, false, err
-		}
+	} else if len(storageMap) > 0 {
 		apiGroupInfo.VersionedResourcesStorageMap[certificatesapiv1.SchemeGroupVersion.Version] = storageMap
 	}
 
@@ -47,16 +45,19 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag
 
 func (p RESTStorageProvider) v1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
+
 	// certificatesigningrequests
+	if resource := "certificatesigningrequests"; apiResourceConfigSource.ResourceEnabled(certificatesapiv1.SchemeGroupVersion.WithResource(resource)) {
 		csrStorage, csrStatusStorage, csrApprovalStorage, err := certificatestore.NewREST(restOptionsGetter)
 		if err != nil {
 			return storage, err
 		}
-	storage["certificatesigningrequests"] = csrStorage
+		storage[resource] = csrStorage
-	storage["certificatesigningrequests/status"] = csrStatusStorage
+		storage[resource+"/status"] = csrStatusStorage
-	storage["certificatesigningrequests/approval"] = csrApprovalStorage
+		storage[resource+"/approval"] = csrApprovalStorage
+	}
 
-	return storage, err
+	return storage, nil
 }
 
 func (p RESTStorageProvider) GroupName() string {

pkg/registry/coordination/rest/storage_coordination.go

@@ -34,26 +34,26 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag
 	// If you add a version here, be sure to add an entry in `k8s.io/kubernetes/cmd/kube-apiserver/app/aggregator.go with specific priorities.
 	// TODO refactor the plumbing to provide the information in the APIGroupInfo
 
-	if apiResourceConfigSource.VersionEnabled(coordinationv1.SchemeGroupVersion) {
 	if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
 		return genericapiserver.APIGroupInfo{}, false, err
-		} else {
+	} else if len(storageMap) > 0 {
 		apiGroupInfo.VersionedResourcesStorageMap[coordinationv1.SchemeGroupVersion.Version] = storageMap
 	}
-	}
 	return apiGroupInfo, true, nil
 }
 
 func (p RESTStorageProvider) v1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
+
 	// leases
+	if resource := "leases"; apiResourceConfigSource.ResourceEnabled(coordinationv1.SchemeGroupVersion.WithResource(resource)) {
 		leaseStorage, err := leasestorage.NewREST(restOptionsGetter)
 		if err != nil {
 			return storage, err
 		}
-	storage["leases"] = leaseStorage
+		storage[resource] = leaseStorage
-
+	}
-	return storage, err
+	return storage, nil
 }
 
 func (p RESTStorageProvider) GroupName() string {