diff --git a/pkg/controlplane/instance.go b/pkg/controlplane/instance.go index fddbf1bb604..6c72f40d270 100644 --- a/pkg/controlplane/instance.go +++ b/pkg/controlplane/instance.go @@ -392,24 +392,9 @@ func (c completedConfig) New(delegationTarget genericapiserver.DelegationTarget) } // install legacy rest storage - if c.ExtraConfig.APIResourceConfigSource.VersionEnabled(apiv1.SchemeGroupVersion) { - legacyRESTStorageProvider := corerest.LegacyRESTStorageProvider{ - StorageFactory: c.ExtraConfig.StorageFactory, - ProxyTransport: c.ExtraConfig.ProxyTransport, - KubeletClientConfig: c.ExtraConfig.KubeletClientConfig, - EventTTL: c.ExtraConfig.EventTTL, - ServiceIPRange: c.ExtraConfig.ServiceIPRange, - SecondaryServiceIPRange: c.ExtraConfig.SecondaryServiceIPRange, - ServiceNodePortRange: c.ExtraConfig.ServiceNodePortRange, - LoopbackClientConfig: c.GenericConfig.LoopbackClientConfig, - ServiceAccountIssuer: c.ExtraConfig.ServiceAccountIssuer, - ExtendExpiration: c.ExtraConfig.ExtendExpiration, - ServiceAccountMaxExpiration: c.ExtraConfig.ServiceAccountMaxExpiration, - APIAudiences: c.GenericConfig.Authentication.APIAudiences, - } - if err := m.InstallLegacyAPI(&c, c.GenericConfig.RESTOptionsGetter, legacyRESTStorageProvider); err != nil { - return nil, err - } + + if err := m.InstallLegacyAPI(&c, c.GenericConfig.RESTOptionsGetter); err != nil { + return nil, err } // The order here is preserved in discovery. @@ -524,11 +509,28 @@ func labelAPIServerHeartbeat(lease *coordinationapiv1.Lease) error { } // InstallLegacyAPI will install the legacy APIs for the restStorageProviders if they are enabled. -func (m *Instance) InstallLegacyAPI(c *completedConfig, restOptionsGetter generic.RESTOptionsGetter, legacyRESTStorageProvider corerest.LegacyRESTStorageProvider) error { - legacyRESTStorage, apiGroupInfo, err := legacyRESTStorageProvider.NewLegacyRESTStorage(restOptionsGetter) +func (m *Instance) InstallLegacyAPI(c *completedConfig, restOptionsGetter generic.RESTOptionsGetter) error { + legacyRESTStorageProvider := corerest.LegacyRESTStorageProvider{ + StorageFactory: c.ExtraConfig.StorageFactory, + ProxyTransport: c.ExtraConfig.ProxyTransport, + KubeletClientConfig: c.ExtraConfig.KubeletClientConfig, + EventTTL: c.ExtraConfig.EventTTL, + ServiceIPRange: c.ExtraConfig.ServiceIPRange, + SecondaryServiceIPRange: c.ExtraConfig.SecondaryServiceIPRange, + ServiceNodePortRange: c.ExtraConfig.ServiceNodePortRange, + LoopbackClientConfig: c.GenericConfig.LoopbackClientConfig, + ServiceAccountIssuer: c.ExtraConfig.ServiceAccountIssuer, + ExtendExpiration: c.ExtraConfig.ExtendExpiration, + ServiceAccountMaxExpiration: c.ExtraConfig.ServiceAccountMaxExpiration, + APIAudiences: c.GenericConfig.Authentication.APIAudiences, + } + legacyRESTStorage, apiGroupInfo, err := legacyRESTStorageProvider.NewLegacyRESTStorage(c.ExtraConfig.APIResourceConfigSource, restOptionsGetter) if err != nil { return fmt.Errorf("error building core storage: %v", err) } + if len(apiGroupInfo.VersionedResourcesStorageMap) == 0 { // if all core storage is disabled, return. + return nil + } controllerName := "bootstrap-controller" coreClient := corev1client.NewForConfigOrDie(c.GenericConfig.LoopbackClientConfig) diff --git a/pkg/controlplane/instance_test.go b/pkg/controlplane/instance_test.go index bd57ec46808..06dade03301 100644 --- a/pkg/controlplane/instance_test.go +++ b/pkg/controlplane/instance_test.go @@ -39,6 +39,7 @@ import ( genericapiserver "k8s.io/apiserver/pkg/server" "k8s.io/apiserver/pkg/server/options" "k8s.io/apiserver/pkg/server/resourceconfig" + "k8s.io/apiserver/pkg/server/storage" serverstorage "k8s.io/apiserver/pkg/server/storage" etcd3testing "k8s.io/apiserver/pkg/storage/etcd3/testing" "k8s.io/client-go/discovery" @@ -156,7 +157,7 @@ func TestLegacyRestStorageStrategies(t *testing.T) { LoopbackClientConfig: apiserverCfg.GenericConfig.LoopbackClientConfig, } - _, apiGroupInfo, err := storageProvider.NewLegacyRESTStorage(apiserverCfg.GenericConfig.RESTOptionsGetter) + _, apiGroupInfo, err := storageProvider.NewLegacyRESTStorage(storage.NewResourceConfig(), apiserverCfg.GenericConfig.RESTOptionsGetter) if err != nil { t.Errorf("failed to create legacy REST storage: %v", err) } diff --git a/pkg/registry/core/rest/storage_core.go b/pkg/registry/core/rest/storage_core.go index fade27bbb5c..8feae659016 100644 --- a/pkg/registry/core/rest/storage_core.go +++ b/pkg/registry/core/rest/storage_core.go @@ -27,6 +27,7 @@ import ( "k8s.io/klog/v2" + corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/runtime/schema" utilnet "k8s.io/apimachinery/pkg/util/net" "k8s.io/apiserver/pkg/authentication/authenticator" @@ -102,7 +103,7 @@ type LegacyRESTStorage struct { ServiceNodePortAllocator rangeallocation.RangeRegistry } -func (c LegacyRESTStorageProvider) NewLegacyRESTStorage(restOptionsGetter generic.RESTOptionsGetter) (LegacyRESTStorage, genericapiserver.APIGroupInfo, error) { +func (c LegacyRESTStorageProvider) NewLegacyRESTStorage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (LegacyRESTStorage, genericapiserver.APIGroupInfo, error) { apiGroupInfo := genericapiserver.APIGroupInfo{ PrioritizedVersions: legacyscheme.Scheme.PrioritizedVersionsForGroup(""), VersionedResourcesStorageMap: map[string]map[string]rest.Storage{}, @@ -273,63 +274,107 @@ func (c LegacyRESTStorageProvider) NewLegacyRESTStorage(restOptionsGetter generi return LegacyRESTStorage{}, genericapiserver.APIGroupInfo{}, err } - restStorageMap := map[string]rest.Storage{ - "pods": podStorage.Pod, - "pods/attach": podStorage.Attach, - "pods/status": podStorage.Status, - "pods/log": podStorage.Log, - "pods/exec": podStorage.Exec, - "pods/portforward": podStorage.PortForward, - "pods/proxy": podStorage.Proxy, - "pods/binding": podStorage.Binding, - "bindings": podStorage.LegacyBinding, + storage := map[string]rest.Storage{} + if resource := "pods"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = podStorage.Pod + storage[resource+"/attach"] = podStorage.Attach + storage[resource+"/status"] = podStorage.Status + storage[resource+"/log"] = podStorage.Log + storage[resource+"/exec"] = podStorage.Exec + storage[resource+"/portforward"] = podStorage.PortForward + storage[resource+"/proxy"] = podStorage.Proxy + storage[resource+"/binding"] = podStorage.Binding + if podStorage.Eviction != nil { + storage[resource+"/eviction"] = podStorage.Eviction + } + if utilfeature.DefaultFeatureGate.Enabled(features.EphemeralContainers) { + storage[resource+"/ephemeralcontainers"] = podStorage.EphemeralContainers + } - "podTemplates": podTemplateStorage, - - "replicationControllers": controllerStorage.Controller, - "replicationControllers/status": controllerStorage.Status, - - "services": serviceRESTStorage, - "services/proxy": serviceRESTProxy, - "services/status": serviceStatusStorage, - - "endpoints": endpointsStorage, - - "nodes": nodeStorage.Node, - "nodes/status": nodeStorage.Status, - "nodes/proxy": nodeStorage.Proxy, - - "events": eventStorage, - - "limitRanges": limitRangeStorage, - "resourceQuotas": resourceQuotaStorage, - "resourceQuotas/status": resourceQuotaStatusStorage, - "namespaces": namespaceStorage, - "namespaces/status": namespaceStatusStorage, - "namespaces/finalize": namespaceFinalizeStorage, - "secrets": secretStorage, - "serviceAccounts": serviceAccountStorage, - "persistentVolumes": persistentVolumeStorage, - "persistentVolumes/status": persistentVolumeStatusStorage, - "persistentVolumeClaims": persistentVolumeClaimStorage, - "persistentVolumeClaims/status": persistentVolumeClaimStatusStorage, - "configMaps": configMapStorage, - - "componentStatuses": componentstatus.NewStorage(componentStatusStorage{c.StorageFactory}.serversToValidate), } - if legacyscheme.Scheme.IsVersionRegistered(schema.GroupVersion{Group: "autoscaling", Version: "v1"}) { - restStorageMap["replicationControllers/scale"] = controllerStorage.Scale + if resource := "bindings"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = podStorage.LegacyBinding } - if podStorage.Eviction != nil { - restStorageMap["pods/eviction"] = podStorage.Eviction + + if resource := "podtemplates"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = podTemplateStorage } - if serviceAccountStorage.Token != nil { - restStorageMap["serviceaccounts/token"] = serviceAccountStorage.Token + + if resource := "replicationcontrollers"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = controllerStorage.Controller + storage[resource+"/status"] = controllerStorage.Status + if legacyscheme.Scheme.IsVersionRegistered(schema.GroupVersion{Group: "autoscaling", Version: "v1"}) { + storage[resource+"/scale"] = controllerStorage.Scale + } } - if utilfeature.DefaultFeatureGate.Enabled(features.EphemeralContainers) { - restStorageMap["pods/ephemeralcontainers"] = podStorage.EphemeralContainers + + if resource := "services"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = serviceRESTStorage + storage[resource+"/proxy"] = serviceRESTProxy + storage[resource+"/status"] = serviceStatusStorage + } + + if resource := "endpoints"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = endpointsStorage + } + + if resource := "nodes"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = nodeStorage.Node + storage[resource+"/proxy"] = nodeStorage.Proxy + storage[resource+"/status"] = nodeStorage.Status + } + + if resource := "events"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = eventStorage + } + + if resource := "limitranges"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = limitRangeStorage + } + + if resource := "resourcequotas"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = resourceQuotaStorage + storage[resource+"/status"] = resourceQuotaStatusStorage + } + + if resource := "namespaces"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = namespaceStorage + storage[resource+"/status"] = namespaceStatusStorage + storage[resource+"/finalize"] = namespaceFinalizeStorage + } + + if resource := "secrets"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = secretStorage + } + + if resource := "serviceaccounts"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = serviceAccountStorage + if serviceAccountStorage.Token != nil { + storage[resource+"/token"] = serviceAccountStorage.Token + } + } + + if resource := "persistentvolumes"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = persistentVolumeStorage + storage[resource+"/status"] = persistentVolumeStatusStorage + } + + if resource := "persistentvolumeclaims"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = persistentVolumeClaimStorage + storage[resource+"/status"] = persistentVolumeClaimStatusStorage + } + + if resource := "configmaps"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = configMapStorage + } + + if resource := "componentstatuses"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = componentstatus.NewStorage(componentStatusStorage{c.StorageFactory}.serversToValidate) + } + + if len(storage) > 0 { + apiGroupInfo.VersionedResourcesStorageMap["v1"] = storage } - apiGroupInfo.VersionedResourcesStorageMap["v1"] = restStorageMap return restStorage, apiGroupInfo, nil } diff --git a/pkg/registry/discovery/rest/storage_discovery.go b/pkg/registry/discovery/rest/storage_discovery.go index 527a236eaad..0f30206a2ec 100644 --- a/pkg/registry/discovery/rest/storage_discovery.go +++ b/pkg/registry/discovery/rest/storage_discovery.go @@ -37,19 +37,15 @@ 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(discoveryv1beta1.SchemeGroupVersion) { - storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter) - if err != nil { - return genericapiserver.APIGroupInfo{}, false, err - } + if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { + return genericapiserver.APIGroupInfo{}, false, err + } else if len(storageMap) > 0 { apiGroupInfo.VersionedResourcesStorageMap[discoveryv1beta1.SchemeGroupVersion.Version] = storageMap } - if apiResourceConfigSource.VersionEnabled(discoveryv1.SchemeGroupVersion) { - storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter) - if err != nil { - return genericapiserver.APIGroupInfo{}, false, err - } + if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { + return genericapiserver.APIGroupInfo{}, false, err + } else if len(storageMap) > 0 { apiGroupInfo.VersionedResourcesStorageMap[discoveryv1.SchemeGroupVersion.Version] = storageMap } @@ -59,25 +55,29 @@ func (p StorageProvider) NewRESTStorage(apiResourceConfigSource serverstorage.AP func (p StorageProvider) v1beta1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) { storage := map[string]rest.Storage{} - endpointSliceStorage, err := endpointslicestorage.NewREST(restOptionsGetter) - if err != nil { - return storage, err + if resource := "endpointslices"; apiResourceConfigSource.ResourceEnabled(discoveryv1beta1.SchemeGroupVersion.WithResource(resource)) { + endpointSliceStorage, err := endpointslicestorage.NewREST(restOptionsGetter) + if err != nil { + return storage, err + } + storage[resource] = endpointSliceStorage } - storage["endpointslices"] = endpointSliceStorage - return storage, err + return storage, nil } func (p StorageProvider) v1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) { storage := map[string]rest.Storage{} - endpointSliceStorage, err := endpointslicestorage.NewREST(restOptionsGetter) - if err != nil { - return storage, err + if resource := "endpointslices"; apiResourceConfigSource.ResourceEnabled(discoveryv1.SchemeGroupVersion.WithResource(resource)) { + endpointSliceStorage, err := endpointslicestorage.NewREST(restOptionsGetter) + if err != nil { + return storage, err + } + storage[resource] = endpointSliceStorage } - storage["endpointslices"] = endpointSliceStorage - return storage, err + return storage, nil } // GroupName is the group name for the storage provider. diff --git a/pkg/registry/events/rest/storage_events.go b/pkg/registry/events/rest/storage_events.go index 6ee689e10af..c727d4440d0 100644 --- a/pkg/registry/events/rest/storage_events.go +++ b/pkg/registry/events/rest/storage_events.go @@ -39,19 +39,16 @@ 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(eventsapiv1beta1.SchemeGroupVersion) { - if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { - return genericapiserver.APIGroupInfo{}, false, err - } else { - apiGroupInfo.VersionedResourcesStorageMap[eventsapiv1beta1.SchemeGroupVersion.Version] = storageMap - } + if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { + return genericapiserver.APIGroupInfo{}, false, err + } else if len(storageMap) > 0 { + apiGroupInfo.VersionedResourcesStorageMap[eventsapiv1beta1.SchemeGroupVersion.Version] = storageMap } - if apiResourceConfigSource.VersionEnabled(eventsapiv1.SchemeGroupVersion) { - if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { - return genericapiserver.APIGroupInfo{}, false, err - } else { - apiGroupInfo.VersionedResourcesStorageMap[eventsapiv1.SchemeGroupVersion.Version] = storageMap - } + + if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { + return genericapiserver.APIGroupInfo{}, false, err + } else if len(storageMap) > 0 { + apiGroupInfo.VersionedResourcesStorageMap[eventsapiv1.SchemeGroupVersion.Version] = storageMap } return apiGroupInfo, true, nil @@ -59,26 +56,32 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag func (p RESTStorageProvider) v1beta1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) { storage := map[string]rest.Storage{} - // events - eventsStorage, err := eventstore.NewREST(restOptionsGetter, uint64(p.TTL.Seconds())) - if err != nil { - return storage, err - } - storage["events"] = eventsStorage - return storage, err + // events + if resource := "events"; apiResourceConfigSource.ResourceEnabled(eventsapiv1beta1.SchemeGroupVersion.WithResource(resource)) { + eventsStorage, err := eventstore.NewREST(restOptionsGetter, uint64(p.TTL.Seconds())) + if err != nil { + return storage, err + } + storage[resource] = eventsStorage + } + + return storage, nil } func (p RESTStorageProvider) v1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) { storage := map[string]rest.Storage{} - // events - eventsStorage, err := eventstore.NewREST(restOptionsGetter, uint64(p.TTL.Seconds())) - if err != nil { - return storage, err - } - storage["events"] = eventsStorage - return storage, err + // events + if resource := "events"; apiResourceConfigSource.ResourceEnabled(eventsapiv1.SchemeGroupVersion.WithResource(resource)) { + eventsStorage, err := eventstore.NewREST(restOptionsGetter, uint64(p.TTL.Seconds())) + if err != nil { + return storage, err + } + storage[resource] = eventsStorage + } + + return storage, nil } func (p RESTStorageProvider) GroupName() string { diff --git a/pkg/registry/flowcontrol/rest/storage_flowcontrol.go b/pkg/registry/flowcontrol/rest/storage_flowcontrol.go index 7d2076294f6..c6084d93ae6 100644 --- a/pkg/registry/flowcontrol/rest/storage_flowcontrol.go +++ b/pkg/registry/flowcontrol/rest/storage_flowcontrol.go @@ -21,6 +21,7 @@ import ( "fmt" "time" + "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/util/wait" flowcontrolbootstrap "k8s.io/apiserver/pkg/apis/flowcontrol/bootstrap" "k8s.io/apiserver/pkg/registry/generic" @@ -56,51 +57,49 @@ const PostStartHookName = "priority-and-fairness-config-producer" func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (genericapiserver.APIGroupInfo, bool, error) { apiGroupInfo := genericapiserver.NewDefaultAPIGroupInfo(flowcontrol.GroupName, legacyscheme.Scheme, legacyscheme.ParameterCodec, legacyscheme.Codecs) - if apiResourceConfigSource.VersionEnabled(flowcontrolapisv1alpha1.SchemeGroupVersion) { - flowControlStorage, err := p.storage(apiResourceConfigSource, restOptionsGetter) - if err != nil { - return genericapiserver.APIGroupInfo{}, false, err - } - apiGroupInfo.VersionedResourcesStorageMap[flowcontrolapisv1alpha1.SchemeGroupVersion.Version] = flowControlStorage + if storageMap, err := p.storage(apiResourceConfigSource, restOptionsGetter, flowcontrolapisv1alpha1.SchemeGroupVersion); err != nil { + return genericapiserver.APIGroupInfo{}, false, err + } else if len(storageMap) > 0 { + apiGroupInfo.VersionedResourcesStorageMap[flowcontrolapisv1alpha1.SchemeGroupVersion.Version] = storageMap } - if apiResourceConfigSource.VersionEnabled(flowcontrolapisv1beta1.SchemeGroupVersion) { - flowControlStorage, err := p.storage(apiResourceConfigSource, restOptionsGetter) - if err != nil { - return genericapiserver.APIGroupInfo{}, false, err - } - apiGroupInfo.VersionedResourcesStorageMap[flowcontrolapisv1beta1.SchemeGroupVersion.Version] = flowControlStorage + if storageMap, err := p.storage(apiResourceConfigSource, restOptionsGetter, flowcontrolapisv1beta1.SchemeGroupVersion); err != nil { + return genericapiserver.APIGroupInfo{}, false, err + } else if len(storageMap) > 0 { + apiGroupInfo.VersionedResourcesStorageMap[flowcontrolapisv1beta1.SchemeGroupVersion.Version] = storageMap } - if apiResourceConfigSource.VersionEnabled(flowcontrolapisv1beta2.SchemeGroupVersion) { - flowControlStorage, err := p.storage(apiResourceConfigSource, restOptionsGetter) - if err != nil { - return genericapiserver.APIGroupInfo{}, false, err - } - apiGroupInfo.VersionedResourcesStorageMap[flowcontrolapisv1beta2.SchemeGroupVersion.Version] = flowControlStorage + if storageMap, err := p.storage(apiResourceConfigSource, restOptionsGetter, flowcontrolapisv1beta2.SchemeGroupVersion); err != nil { + return genericapiserver.APIGroupInfo{}, false, err + } else if len(storageMap) > 0 { + apiGroupInfo.VersionedResourcesStorageMap[flowcontrolapisv1beta2.SchemeGroupVersion.Version] = storageMap } return apiGroupInfo, true, nil } -func (p RESTStorageProvider) storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) { +func (p RESTStorageProvider) storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter, groupVersion schema.GroupVersion) (map[string]rest.Storage, error) { storage := map[string]rest.Storage{} // flow-schema - flowSchemaStorage, flowSchemaStatusStorage, err := flowschemastore.NewREST(restOptionsGetter) - if err != nil { - return nil, err + if resource := "flowschemas"; apiResourceConfigSource.ResourceEnabled(groupVersion.WithResource(resource)) { + flowSchemaStorage, flowSchemaStatusStorage, err := flowschemastore.NewREST(restOptionsGetter) + if err != nil { + return nil, err + } + storage[resource] = flowSchemaStorage + storage[resource+"/status"] = flowSchemaStatusStorage } - storage["flowschemas"] = flowSchemaStorage - storage["flowschemas/status"] = flowSchemaStatusStorage // priority-level-configuration - priorityLevelConfigurationStorage, priorityLevelConfigurationStatusStorage, err := prioritylevelconfigurationstore.NewREST(restOptionsGetter) - if err != nil { - return nil, err + if resource := "prioritylevelconfigurations"; apiResourceConfigSource.ResourceEnabled(groupVersion.WithResource(resource)) { + priorityLevelConfigurationStorage, priorityLevelConfigurationStatusStorage, err := prioritylevelconfigurationstore.NewREST(restOptionsGetter) + if err != nil { + return nil, err + } + storage[resource] = priorityLevelConfigurationStorage + storage[resource+"/status"] = priorityLevelConfigurationStatusStorage } - storage["prioritylevelconfigurations"] = priorityLevelConfigurationStorage - storage["prioritylevelconfigurations/status"] = priorityLevelConfigurationStatusStorage return storage, nil } diff --git a/pkg/registry/networking/rest/storage_settings.go b/pkg/registry/networking/rest/storage_settings.go index 2ff3d0a0bf1..bb84bdb42a2 100644 --- a/pkg/registry/networking/rest/storage_settings.go +++ b/pkg/registry/networking/rest/storage_settings.go @@ -36,12 +36,10 @@ 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(networkingapiv1.SchemeGroupVersion) { - if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { - return genericapiserver.APIGroupInfo{}, false, err - } else { - apiGroupInfo.VersionedResourcesStorageMap[networkingapiv1.SchemeGroupVersion.Version] = storageMap - } + if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { + return genericapiserver.APIGroupInfo{}, false, err + } else if len(storageMap) > 0 { + apiGroupInfo.VersionedResourcesStorageMap[networkingapiv1.SchemeGroupVersion.Version] = storageMap } return apiGroupInfo, true, nil @@ -49,27 +47,34 @@ 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{} + // networkpolicies - networkPolicyStorage, err := networkpolicystore.NewREST(restOptionsGetter) - if err != nil { - return storage, err + if resource := "networkpolicies"; apiResourceConfigSource.ResourceEnabled(networkingapiv1.SchemeGroupVersion.WithResource(resource)) { + networkPolicyStorage, err := networkpolicystore.NewREST(restOptionsGetter) + if err != nil { + return storage, err + } + storage[resource] = networkPolicyStorage } - storage["networkpolicies"] = networkPolicyStorage // ingresses - ingressStorage, ingressStatusStorage, err := ingressstore.NewREST(restOptionsGetter) - if err != nil { - return storage, err + if resource := "ingresses"; apiResourceConfigSource.ResourceEnabled(networkingapiv1.SchemeGroupVersion.WithResource(resource)) { + ingressStorage, ingressStatusStorage, err := ingressstore.NewREST(restOptionsGetter) + if err != nil { + return storage, err + } + storage[resource] = ingressStorage + storage[resource+"/status"] = ingressStatusStorage } - storage["ingresses"] = ingressStorage - storage["ingresses/status"] = ingressStatusStorage // ingressclasses - ingressClassStorage, err := ingressclassstore.NewREST(restOptionsGetter) - if err != nil { - return storage, err + if resource := "ingressclasses"; apiResourceConfigSource.ResourceEnabled(networkingapiv1.SchemeGroupVersion.WithResource(resource)) { + ingressClassStorage, err := ingressclassstore.NewREST(restOptionsGetter) + if err != nil { + return storage, err + } + storage[resource] = ingressClassStorage } - storage["ingressclasses"] = ingressClassStorage return storage, nil } diff --git a/pkg/registry/node/rest/runtime_class.go b/pkg/registry/node/rest/runtime_class.go index c925f4c9332..eb27fed82cb 100644 --- a/pkg/registry/node/rest/runtime_class.go +++ b/pkg/registry/node/rest/runtime_class.go @@ -36,28 +36,22 @@ type RESTStorageProvider struct{} func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (genericapiserver.APIGroupInfo, bool, error) { apiGroupInfo := genericapiserver.NewDefaultAPIGroupInfo(nodeinternal.GroupName, legacyscheme.Scheme, legacyscheme.ParameterCodec, legacyscheme.Codecs) - if apiResourceConfigSource.VersionEnabled(nodev1alpha1.SchemeGroupVersion) { - if storageMap, err := p.v1alpha1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { - return genericapiserver.APIGroupInfo{}, false, err - } else { - apiGroupInfo.VersionedResourcesStorageMap[nodev1alpha1.SchemeGroupVersion.Version] = storageMap - } + if storageMap, err := p.v1alpha1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { + return genericapiserver.APIGroupInfo{}, false, err + } else if len(storageMap) > 0 { + apiGroupInfo.VersionedResourcesStorageMap[nodev1alpha1.SchemeGroupVersion.Version] = storageMap } - if apiResourceConfigSource.VersionEnabled(nodev1beta1.SchemeGroupVersion) { - if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { - return genericapiserver.APIGroupInfo{}, false, err - } else { - apiGroupInfo.VersionedResourcesStorageMap[nodev1beta1.SchemeGroupVersion.Version] = storageMap - } + if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { + return genericapiserver.APIGroupInfo{}, false, err + } else if len(storageMap) > 0 { + apiGroupInfo.VersionedResourcesStorageMap[nodev1beta1.SchemeGroupVersion.Version] = storageMap } - if apiResourceConfigSource.VersionEnabled(nodev1.SchemeGroupVersion) { - if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { - return genericapiserver.APIGroupInfo{}, false, err - } else { - apiGroupInfo.VersionedResourcesStorageMap[nodev1.SchemeGroupVersion.Version] = storageMap - } + if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { + return genericapiserver.APIGroupInfo{}, false, err + } else if len(storageMap) > 0 { + apiGroupInfo.VersionedResourcesStorageMap[nodev1.SchemeGroupVersion.Version] = storageMap } return apiGroupInfo, true, nil @@ -65,35 +59,44 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag func (p RESTStorageProvider) v1alpha1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) { storage := map[string]rest.Storage{} - s, err := runtimeclassstorage.NewREST(restOptionsGetter) - if err != nil { - return storage, err - } - storage["runtimeclasses"] = s - return storage, err + if resource := "runtimeclasses"; apiResourceConfigSource.ResourceEnabled(nodev1alpha1.SchemeGroupVersion.WithResource(resource)) { + s, err := runtimeclassstorage.NewREST(restOptionsGetter) + if err != nil { + return storage, err + } + storage[resource] = s + } + + return storage, nil } func (p RESTStorageProvider) v1beta1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) { storage := map[string]rest.Storage{} - s, err := runtimeclassstorage.NewREST(restOptionsGetter) - if err != nil { - return storage, err - } - storage["runtimeclasses"] = s - return storage, err + if resource := "runtimeclasses"; apiResourceConfigSource.ResourceEnabled(nodev1beta1.SchemeGroupVersion.WithResource(resource)) { + s, err := runtimeclassstorage.NewREST(restOptionsGetter) + if err != nil { + return storage, err + } + storage[resource] = s + } + + return storage, nil } func (p RESTStorageProvider) v1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) { storage := map[string]rest.Storage{} - s, err := runtimeclassstorage.NewREST(restOptionsGetter) - if err != nil { - return storage, err - } - storage["runtimeclasses"] = s - return storage, err + if resource := "runtimeclasses"; apiResourceConfigSource.ResourceEnabled(nodev1.SchemeGroupVersion.WithResource(resource)) { + s, err := runtimeclassstorage.NewREST(restOptionsGetter) + if err != nil { + return storage, err + } + storage[resource] = s + } + + return storage, nil } // GroupName is the group name for the storage provider diff --git a/pkg/registry/policy/rest/storage_policy.go b/pkg/registry/policy/rest/storage_policy.go index a3c34079608..5b4f4d0cbe3 100644 --- a/pkg/registry/policy/rest/storage_policy.go +++ b/pkg/registry/policy/rest/storage_policy.go @@ -36,54 +36,58 @@ 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(policyapiv1beta1.SchemeGroupVersion) { - if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { - return genericapiserver.APIGroupInfo{}, false, err - } else { - apiGroupInfo.VersionedResourcesStorageMap[policyapiv1beta1.SchemeGroupVersion.Version] = storageMap - } + if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { + return genericapiserver.APIGroupInfo{}, false, err + } else if len(storageMap) > 0 { + apiGroupInfo.VersionedResourcesStorageMap[policyapiv1beta1.SchemeGroupVersion.Version] = storageMap } - if apiResourceConfigSource.VersionEnabled(policyapiv1.SchemeGroupVersion) { - if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { - return genericapiserver.APIGroupInfo{}, false, err - } else { - apiGroupInfo.VersionedResourcesStorageMap[policyapiv1.SchemeGroupVersion.Version] = storageMap - } + if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { + return genericapiserver.APIGroupInfo{}, false, err + } else if len(storageMap) > 0 { + apiGroupInfo.VersionedResourcesStorageMap[policyapiv1.SchemeGroupVersion.Version] = storageMap } + return apiGroupInfo, true, nil } func (p RESTStorageProvider) v1beta1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) { storage := map[string]rest.Storage{} + // poddisruptionbudgets - poddisruptionbudgetStorage, poddisruptionbudgetStatusStorage, err := poddisruptionbudgetstore.NewREST(restOptionsGetter) - if err != nil { - return storage, err + if resource := "poddisruptionbudgets"; apiResourceConfigSource.ResourceEnabled(policyapiv1beta1.SchemeGroupVersion.WithResource(resource)) { + poddisruptionbudgetStorage, poddisruptionbudgetStatusStorage, err := poddisruptionbudgetstore.NewREST(restOptionsGetter) + if err != nil { + return storage, err + } + storage[resource] = poddisruptionbudgetStorage + storage[resource+"/status"] = poddisruptionbudgetStatusStorage } - storage["poddisruptionbudgets"] = poddisruptionbudgetStorage - storage["poddisruptionbudgets/status"] = poddisruptionbudgetStatusStorage - rest, err := pspstore.NewREST(restOptionsGetter) - if err != nil { - return storage, err + if resource := "podsecuritypolicies"; apiResourceConfigSource.ResourceEnabled(policyapiv1beta1.SchemeGroupVersion.WithResource(resource)) { + rest, err := pspstore.NewREST(restOptionsGetter) + if err != nil { + return storage, err + } + storage[resource] = rest } - storage["podsecuritypolicies"] = rest - return storage, err + return storage, nil } func (p RESTStorageProvider) v1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) { storage := map[string]rest.Storage{} - poddisruptionbudgetStorage, poddisruptionbudgetStatusStorage, err := poddisruptionbudgetstore.NewREST(restOptionsGetter) - if err != nil { - return storage, err + if resource := "poddisruptionbudgets"; apiResourceConfigSource.ResourceEnabled(policyapiv1.SchemeGroupVersion.WithResource(resource)) { + poddisruptionbudgetStorage, poddisruptionbudgetStatusStorage, err := poddisruptionbudgetstore.NewREST(restOptionsGetter) + if err != nil { + return storage, err + } + storage[resource] = poddisruptionbudgetStorage + storage[resource+"/status"] = poddisruptionbudgetStatusStorage } - storage["poddisruptionbudgets"] = poddisruptionbudgetStorage - storage["poddisruptionbudgets/status"] = poddisruptionbudgetStatusStorage - return storage, err + return storage, nil } func (p RESTStorageProvider) GroupName() string { diff --git a/pkg/registry/rbac/rest/storage_rbac.go b/pkg/registry/rbac/rest/storage_rbac.go index e73b332ba6a..964acc43138 100644 --- a/pkg/registry/rbac/rest/storage_rbac.go +++ b/pkg/registry/rbac/rest/storage_rbac.go @@ -70,12 +70,10 @@ 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(rbacapiv1.SchemeGroupVersion) { - if storageMap, err := p.storage(rbacapiv1.SchemeGroupVersion, apiResourceConfigSource, restOptionsGetter); err != nil { - return genericapiserver.APIGroupInfo{}, false, err - } else { - apiGroupInfo.VersionedResourcesStorageMap[rbacapiv1.SchemeGroupVersion.Version] = storageMap - } + if storageMap, err := p.storage(rbacapiv1.SchemeGroupVersion, apiResourceConfigSource, restOptionsGetter); err != nil { + return genericapiserver.APIGroupInfo{}, false, err + } else if len(storageMap) > 0 { + apiGroupInfo.VersionedResourcesStorageMap[rbacapiv1.SchemeGroupVersion.Version] = storageMap } return apiGroupInfo, true, nil @@ -83,6 +81,7 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag func (p RESTStorageProvider) storage(version schema.GroupVersion, apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) { storage := map[string]rest.Storage{} + rolesStorage, err := rolestore.NewREST(restOptionsGetter) if err != nil { return storage, err @@ -108,16 +107,24 @@ func (p RESTStorageProvider) storage(version schema.GroupVersion, apiResourceCon ) // roles - storage["roles"] = rolepolicybased.NewStorage(rolesStorage, p.Authorizer, authorizationRuleResolver) + if resource := "roles"; apiResourceConfigSource.ResourceEnabled(rbacapiv1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = rolepolicybased.NewStorage(rolesStorage, p.Authorizer, authorizationRuleResolver) + } // rolebindings - storage["rolebindings"] = rolebindingpolicybased.NewStorage(roleBindingsStorage, p.Authorizer, authorizationRuleResolver) + if resource := "rolebindings"; apiResourceConfigSource.ResourceEnabled(rbacapiv1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = rolebindingpolicybased.NewStorage(roleBindingsStorage, p.Authorizer, authorizationRuleResolver) + } // clusterroles - storage["clusterroles"] = clusterrolepolicybased.NewStorage(clusterRolesStorage, p.Authorizer, authorizationRuleResolver) + if resource := "clusterroles"; apiResourceConfigSource.ResourceEnabled(rbacapiv1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = clusterrolepolicybased.NewStorage(clusterRolesStorage, p.Authorizer, authorizationRuleResolver) + } // clusterrolebindings - storage["clusterrolebindings"] = clusterrolebindingpolicybased.NewStorage(clusterRoleBindingsStorage, p.Authorizer, authorizationRuleResolver) + if resource := "clusterrolebindings"; apiResourceConfigSource.ResourceEnabled(rbacapiv1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = clusterrolebindingpolicybased.NewStorage(clusterRoleBindingsStorage, p.Authorizer, authorizationRuleResolver) + } return storage, nil } diff --git a/pkg/registry/scheduling/rest/storage_scheduling.go b/pkg/registry/scheduling/rest/storage_scheduling.go index be529711ab0..26930931831 100644 --- a/pkg/registry/scheduling/rest/storage_scheduling.go +++ b/pkg/registry/scheduling/rest/storage_scheduling.go @@ -47,23 +47,25 @@ var _ genericapiserver.PostStartHookProvider = RESTStorageProvider{} func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (genericapiserver.APIGroupInfo, bool, error) { apiGroupInfo := genericapiserver.NewDefaultAPIGroupInfo(scheduling.GroupName, legacyscheme.Scheme, legacyscheme.ParameterCodec, legacyscheme.Codecs) - if apiResourceConfigSource.VersionEnabled(schedulingapiv1.SchemeGroupVersion) { - if storage, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { - return genericapiserver.APIGroupInfo{}, false, err - } else { - apiGroupInfo.VersionedResourcesStorageMap[schedulingapiv1.SchemeGroupVersion.Version] = storage - } + if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { + return genericapiserver.APIGroupInfo{}, false, err + } else if len(storageMap) > 0 { + apiGroupInfo.VersionedResourcesStorageMap[schedulingapiv1.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{} + // priorityclasses - if priorityClassStorage, err := priorityclassstore.NewREST(restOptionsGetter); err != nil { - return nil, err - } else { - storage["priorityclasses"] = priorityClassStorage + if resource := "priorityclasses"; apiResourceConfigSource.ResourceEnabled(schedulingapiv1.SchemeGroupVersion.WithResource(resource)) { + if priorityClassStorage, err := priorityclassstore.NewREST(restOptionsGetter); err != nil { + return nil, err + } else { + storage[resource] = priorityClassStorage + } } return storage, nil diff --git a/pkg/registry/storage/rest/storage_storage.go b/pkg/registry/storage/rest/storage_storage.go index 4e17538075c..c3280f59ba4 100644 --- a/pkg/registry/storage/rest/storage_storage.go +++ b/pkg/registry/storage/rest/storage_storage.go @@ -41,26 +41,20 @@ 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(storageapiv1alpha1.SchemeGroupVersion) { - if storageMap, err := p.v1alpha1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { - return genericapiserver.APIGroupInfo{}, false, err - } else { - apiGroupInfo.VersionedResourcesStorageMap[storageapiv1alpha1.SchemeGroupVersion.Version] = storageMap - } + if storageMap, err := p.v1alpha1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { + return genericapiserver.APIGroupInfo{}, false, err + } else if len(storageMap) > 0 { + apiGroupInfo.VersionedResourcesStorageMap[storageapiv1alpha1.SchemeGroupVersion.Version] = storageMap } - if apiResourceConfigSource.VersionEnabled(storageapiv1beta1.SchemeGroupVersion) { - if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { - return genericapiserver.APIGroupInfo{}, false, err - } else { - apiGroupInfo.VersionedResourcesStorageMap[storageapiv1beta1.SchemeGroupVersion.Version] = storageMap - } + if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { + return genericapiserver.APIGroupInfo{}, false, err + } else if len(storageMap) > 0 { + apiGroupInfo.VersionedResourcesStorageMap[storageapiv1beta1.SchemeGroupVersion.Version] = storageMap } - if apiResourceConfigSource.VersionEnabled(storageapiv1.SchemeGroupVersion) { - if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { - return genericapiserver.APIGroupInfo{}, false, err - } else { - apiGroupInfo.VersionedResourcesStorageMap[storageapiv1.SchemeGroupVersion.Version] = storageMap - } + if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil { + return genericapiserver.APIGroupInfo{}, false, err + } else if len(storageMap) > 0 { + apiGroupInfo.VersionedResourcesStorageMap[storageapiv1.SchemeGroupVersion.Version] = storageMap } return apiGroupInfo, true, nil @@ -70,11 +64,13 @@ func (p RESTStorageProvider) v1alpha1Storage(apiResourceConfigSource serverstora storage := map[string]rest.Storage{} // register csistoragecapacities - csiStorageStorage, err := csistoragecapacitystore.NewStorage(restOptionsGetter) - if err != nil { - return storage, err + if resource := "csistoragecapacities"; apiResourceConfigSource.ResourceEnabled(storageapiv1alpha1.SchemeGroupVersion.WithResource(resource)) { + csiStorageStorage, err := csistoragecapacitystore.NewStorage(restOptionsGetter) + if err != nil { + return storage, err + } + storage[resource] = csiStorageStorage.CSIStorageCapacity } - storage["csistoragecapacities"] = csiStorageStorage.CSIStorageCapacity return storage, nil } @@ -83,11 +79,13 @@ func (p RESTStorageProvider) v1beta1Storage(apiResourceConfigSource serverstorag storage := map[string]rest.Storage{} // register csistoragecapacities - csiStorageStorage, err := csistoragecapacitystore.NewStorage(restOptionsGetter) - if err != nil { - return storage, err + if resource := "csistoragecapacities"; apiResourceConfigSource.ResourceEnabled(storageapiv1beta1.SchemeGroupVersion.WithResource(resource)) { + csiStorageStorage, err := csistoragecapacitystore.NewStorage(restOptionsGetter) + if err != nil { + return storage, err + } + storage[resource] = csiStorageStorage.CSIStorageCapacity } - storage["csistoragecapacities"] = csiStorageStorage.CSIStorageCapacity return storage, nil } @@ -102,28 +100,36 @@ func (p RESTStorageProvider) v1Storage(apiResourceConfigSource serverstorage.API return nil, err } - storage := map[string]rest.Storage{ - // storageclasses - "storageclasses": storageClassStorage, + storage := map[string]rest.Storage{} - // volumeattachments - "volumeattachments": volumeAttachmentStorage.VolumeAttachment, - "volumeattachments/status": volumeAttachmentStorage.Status, + // storageclasses + if resource := "storageclasses"; apiResourceConfigSource.ResourceEnabled(storageapiv1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = storageClassStorage + } + + // volumeattachments + if resource := "volumeattachments"; apiResourceConfigSource.ResourceEnabled(storageapiv1.SchemeGroupVersion.WithResource(resource)) { + storage[resource] = volumeAttachmentStorage.VolumeAttachment + storage[resource+"/status"] = volumeAttachmentStorage.Status } // register csinodes - csiNodeStorage, err := csinodestore.NewStorage(restOptionsGetter) - if err != nil { - return nil, err + if resource := "csinodes"; apiResourceConfigSource.ResourceEnabled(storageapiv1.SchemeGroupVersion.WithResource(resource)) { + csiNodeStorage, err := csinodestore.NewStorage(restOptionsGetter) + if err != nil { + return nil, err + } + storage[resource] = csiNodeStorage.CSINode } - storage["csinodes"] = csiNodeStorage.CSINode // register csidrivers - csiDriverStorage, err := csidriverstore.NewStorage(restOptionsGetter) - if err != nil { - return storage, err + if resource := "csidrivers"; apiResourceConfigSource.ResourceEnabled(storageapiv1.SchemeGroupVersion.WithResource(resource)) { + csiDriverStorage, err := csidriverstore.NewStorage(restOptionsGetter) + if err != nil { + return storage, err + } + storage[resource] = csiDriverStorage.CSIDriver } - storage["csidrivers"] = csiDriverStorage.CSIDriver return storage, nil } diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/apiserver.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/apiserver.go index f489f074b1a..b54a0e92f00 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/apiserver.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/apiserver.go @@ -149,16 +149,17 @@ func (c completedConfig) New(delegationTarget genericapiserver.DelegationTarget) apiResourceConfig := c.GenericConfig.MergedResourceConfig apiGroupInfo := genericapiserver.NewDefaultAPIGroupInfo(apiextensions.GroupName, Scheme, metav1.ParameterCodec, Codecs) - if apiResourceConfig.VersionEnabled(v1.SchemeGroupVersion) { - storage := map[string]rest.Storage{} - // customresourcedefinitions + storage := map[string]rest.Storage{} + // customresourcedefinitions + if resource := "customresourcedefinitions"; apiResourceConfig.ResourceEnabled(v1.SchemeGroupVersion.WithResource(resource)) { customResourceDefinitionStorage, err := customresourcedefinition.NewREST(Scheme, c.GenericConfig.RESTOptionsGetter) if err != nil { return nil, err } - storage["customresourcedefinitions"] = customResourceDefinitionStorage - storage["customresourcedefinitions/status"] = customresourcedefinition.NewStatusREST(Scheme, customResourceDefinitionStorage) - + storage[resource] = customResourceDefinitionStorage + storage[resource+"/status"] = customresourcedefinition.NewStatusREST(Scheme, customResourceDefinitionStorage) + } + if len(storage) > 0 { apiGroupInfo.VersionedResourcesStorageMap[v1.SchemeGroupVersion.Version] = storage } diff --git a/staging/src/k8s.io/apiserver/pkg/server/genericapiserver.go b/staging/src/k8s.io/apiserver/pkg/server/genericapiserver.go index c530bb59906..d736465bd1a 100644 --- a/staging/src/k8s.io/apiserver/pkg/server/genericapiserver.go +++ b/staging/src/k8s.io/apiserver/pkg/server/genericapiserver.go @@ -539,7 +539,10 @@ func (s *GenericAPIServer) installAPIResources(apiPrefix string, apiGroupInfo *A continue } - apiGroupVersion := s.getAPIGroupVersion(apiGroupInfo, groupVersion, apiPrefix) + apiGroupVersion, err := s.getAPIGroupVersion(apiGroupInfo, groupVersion, apiPrefix) + if err != nil { + return err + } if apiGroupInfo.OptionsExternalVersion != nil { apiGroupVersion.OptionsExternalVersion = apiGroupInfo.OptionsExternalVersion } @@ -652,15 +655,18 @@ func (s *GenericAPIServer) InstallAPIGroup(apiGroupInfo *APIGroupInfo) error { return s.InstallAPIGroups(apiGroupInfo) } -func (s *GenericAPIServer) getAPIGroupVersion(apiGroupInfo *APIGroupInfo, groupVersion schema.GroupVersion, apiPrefix string) *genericapi.APIGroupVersion { +func (s *GenericAPIServer) getAPIGroupVersion(apiGroupInfo *APIGroupInfo, groupVersion schema.GroupVersion, apiPrefix string) (*genericapi.APIGroupVersion, error) { storage := make(map[string]rest.Storage) for k, v := range apiGroupInfo.VersionedResourcesStorageMap[groupVersion.Version] { - storage[strings.ToLower(k)] = v + if strings.ToLower(k) != k { + return nil, fmt.Errorf("resource names must be lowercase only, not %q", k) + } + storage[k] = v } version := s.newAPIGroupVersion(apiGroupInfo, groupVersion) version.Root = apiPrefix version.Storage = storage - return version + return version, nil } func (s *GenericAPIServer) newAPIGroupVersion(apiGroupInfo *APIGroupInfo, groupVersion schema.GroupVersion) *genericapi.APIGroupVersion { diff --git a/staging/src/k8s.io/apiserver/pkg/server/storage/resource_config.go b/staging/src/k8s.io/apiserver/pkg/server/storage/resource_config.go index 78771148d4a..7a409f566c7 100644 --- a/staging/src/k8s.io/apiserver/pkg/server/storage/resource_config.go +++ b/staging/src/k8s.io/apiserver/pkg/server/storage/resource_config.go @@ -22,7 +22,6 @@ import ( // APIResourceConfigSource is the interface to determine which groups and versions are enabled type APIResourceConfigSource interface { - VersionEnabled(version schema.GroupVersion) bool ResourceEnabled(resource schema.GroupVersionResource) bool AnyResourceForGroupEnabled(group string) bool } diff --git a/staging/src/k8s.io/kube-aggregator/pkg/registry/apiservice/rest/storage_apiservice.go b/staging/src/k8s.io/kube-aggregator/pkg/registry/apiservice/rest/storage_apiservice.go index 4ae5205ca05..3c159251c46 100644 --- a/staging/src/k8s.io/kube-aggregator/pkg/registry/apiservice/rest/storage_apiservice.go +++ b/staging/src/k8s.io/kube-aggregator/pkg/registry/apiservice/rest/storage_apiservice.go @@ -33,11 +33,15 @@ import ( func NewRESTStorage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter, shouldServeBeta bool) genericapiserver.APIGroupInfo { apiGroupInfo := genericapiserver.NewDefaultAPIGroupInfo(apiregistration.GroupName, aggregatorscheme.Scheme, metav1.ParameterCodec, aggregatorscheme.Codecs) - if apiResourceConfigSource.VersionEnabled(v1.SchemeGroupVersion) { - storage := map[string]rest.Storage{} + storage := map[string]rest.Storage{} + + if resource := "apiservices"; apiResourceConfigSource.ResourceEnabled(v1.SchemeGroupVersion.WithResource(resource)) { apiServiceREST := apiservicestorage.NewREST(aggregatorscheme.Scheme, restOptionsGetter) - storage["apiservices"] = apiServiceREST - storage["apiservices/status"] = apiservicestorage.NewStatusREST(aggregatorscheme.Scheme, apiServiceREST) + storage[resource] = apiServiceREST + storage[resource+"/status"] = apiservicestorage.NewStatusREST(aggregatorscheme.Scheme, apiServiceREST) + } + + if len(storage) > 0 { apiGroupInfo.VersionedResourcesStorageMap["v1"] = storage }