k8s.io/kubernetes@v1.31.0-alpha.0.0.20240520171757-56147500dadc/pkg/kubeapiserver/default_storage_factory_builder.go (about) 1 /* 2 Copyright 2016 The Kubernetes Authors. 3 4 Licensed under the Apache License, Version 2.0 (the "License"); 5 you may not use this file except in compliance with the License. 6 You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10 Unless required by applicable law or agreed to in writing, software 11 distributed under the License is distributed on an "AS IS" BASIS, 12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 See the License for the specific language governing permissions and 14 limitations under the License. 15 */ 16 17 package kubeapiserver 18 19 import ( 20 "strings" 21 22 "k8s.io/apimachinery/pkg/runtime" 23 "k8s.io/apimachinery/pkg/runtime/schema" 24 serveroptions "k8s.io/apiserver/pkg/server/options" 25 "k8s.io/apiserver/pkg/server/resourceconfig" 26 serverstorage "k8s.io/apiserver/pkg/server/storage" 27 "k8s.io/apiserver/pkg/storage/storagebackend" 28 "k8s.io/kubernetes/pkg/api/legacyscheme" 29 "k8s.io/kubernetes/pkg/apis/admissionregistration" 30 "k8s.io/kubernetes/pkg/apis/apps" 31 "k8s.io/kubernetes/pkg/apis/certificates" 32 api "k8s.io/kubernetes/pkg/apis/core" 33 "k8s.io/kubernetes/pkg/apis/events" 34 "k8s.io/kubernetes/pkg/apis/extensions" 35 "k8s.io/kubernetes/pkg/apis/networking" 36 "k8s.io/kubernetes/pkg/apis/policy" 37 "k8s.io/kubernetes/pkg/apis/storage" 38 "k8s.io/kubernetes/pkg/apis/storagemigration" 39 ) 40 41 // SpecialDefaultResourcePrefixes are prefixes compiled into Kubernetes. 42 var SpecialDefaultResourcePrefixes = map[schema.GroupResource]string{ 43 {Group: "", Resource: "replicationcontrollers"}: "controllers", 44 {Group: "", Resource: "endpoints"}: "services/endpoints", 45 {Group: "", Resource: "nodes"}: "minions", 46 {Group: "", Resource: "services"}: "services/specs", 47 {Group: "extensions", Resource: "ingresses"}: "ingress", 48 {Group: "networking.k8s.io", Resource: "ingresses"}: "ingress", 49 } 50 51 // DefaultWatchCacheSizes defines default resources for which watchcache 52 // should be disabled. 53 func DefaultWatchCacheSizes() map[schema.GroupResource]int { 54 return map[schema.GroupResource]int{ 55 {Resource: "events"}: 0, 56 {Group: "events.k8s.io", Resource: "events"}: 0, 57 } 58 } 59 60 // NewStorageFactoryConfig returns a new StorageFactoryConfig set up with necessary resource overrides. 61 func NewStorageFactoryConfig() *StorageFactoryConfig { 62 resources := []schema.GroupVersionResource{ 63 // If a resource has to be stored in a version that is not the 64 // latest, then it can be listed here. Usually this is the case 65 // when a new version for a resource gets introduced and a 66 // downgrade to an older apiserver that doesn't know the new 67 // version still needs to be supported for one release. 68 // 69 // Example from Kubernetes 1.24 where csistoragecapacities had just 70 // graduated to GA: 71 // 72 // TODO (https://github.com/kubernetes/kubernetes/issues/108451): remove the override in 1.25. 73 // apisstorage.Resource("csistoragecapacities").WithVersion("v1beta1"), 74 admissionregistration.Resource("validatingadmissionpolicies").WithVersion("v1beta1"), 75 admissionregistration.Resource("validatingadmissionpolicybindings").WithVersion("v1beta1"), 76 networking.Resource("ipaddresses").WithVersion("v1alpha1"), 77 networking.Resource("servicecidrs").WithVersion("v1alpha1"), 78 certificates.Resource("clustertrustbundles").WithVersion("v1alpha1"), 79 storage.Resource("volumeattributesclasses").WithVersion("v1alpha1"), 80 storagemigration.Resource("storagemigrations").WithVersion("v1alpha1"), 81 } 82 83 return &StorageFactoryConfig{ 84 Serializer: legacyscheme.Codecs, 85 DefaultResourceEncoding: serverstorage.NewDefaultResourceEncodingConfig(legacyscheme.Scheme), 86 ResourceEncodingOverrides: resources, 87 } 88 } 89 90 // StorageFactoryConfig is a configuration for creating storage factory. 91 type StorageFactoryConfig struct { 92 StorageConfig storagebackend.Config 93 APIResourceConfig *serverstorage.ResourceConfig 94 DefaultResourceEncoding *serverstorage.DefaultResourceEncodingConfig 95 DefaultStorageMediaType string 96 Serializer runtime.StorageSerializer 97 ResourceEncodingOverrides []schema.GroupVersionResource 98 EtcdServersOverrides []string 99 } 100 101 // Complete completes the StorageFactoryConfig with provided etcdOptions returning completedStorageFactoryConfig. 102 // This method mutates the receiver (StorageFactoryConfig). It must never mutate the inputs. 103 func (c *StorageFactoryConfig) Complete(etcdOptions *serveroptions.EtcdOptions) *completedStorageFactoryConfig { 104 c.StorageConfig = etcdOptions.StorageConfig 105 c.DefaultStorageMediaType = etcdOptions.DefaultStorageMediaType 106 c.EtcdServersOverrides = etcdOptions.EtcdServersOverrides 107 return &completedStorageFactoryConfig{c} 108 } 109 110 // completedStorageFactoryConfig is a wrapper around StorageFactoryConfig completed with etcd options. 111 // 112 // Note: this struct is intentionally unexported so that it can only be constructed via a StorageFactoryConfig.Complete 113 // call. The implied consequence is that this does not comply with golint. 114 type completedStorageFactoryConfig struct { 115 *StorageFactoryConfig 116 } 117 118 // New returns a new storage factory created from the completed storage factory configuration. 119 func (c *completedStorageFactoryConfig) New() (*serverstorage.DefaultStorageFactory, error) { 120 resourceEncodingConfig := resourceconfig.MergeResourceEncodingConfigs(c.DefaultResourceEncoding, c.ResourceEncodingOverrides) 121 storageFactory := serverstorage.NewDefaultStorageFactory( 122 c.StorageConfig, 123 c.DefaultStorageMediaType, 124 c.Serializer, 125 resourceEncodingConfig, 126 c.APIResourceConfig, 127 SpecialDefaultResourcePrefixes) 128 129 storageFactory.AddCohabitatingResources(networking.Resource("networkpolicies"), extensions.Resource("networkpolicies")) 130 storageFactory.AddCohabitatingResources(apps.Resource("deployments"), extensions.Resource("deployments")) 131 storageFactory.AddCohabitatingResources(apps.Resource("daemonsets"), extensions.Resource("daemonsets")) 132 storageFactory.AddCohabitatingResources(apps.Resource("replicasets"), extensions.Resource("replicasets")) 133 storageFactory.AddCohabitatingResources(api.Resource("events"), events.Resource("events")) 134 storageFactory.AddCohabitatingResources(api.Resource("replicationcontrollers"), extensions.Resource("replicationcontrollers")) // to make scale subresources equivalent 135 storageFactory.AddCohabitatingResources(policy.Resource("podsecuritypolicies"), extensions.Resource("podsecuritypolicies")) 136 storageFactory.AddCohabitatingResources(networking.Resource("ingresses"), extensions.Resource("ingresses")) 137 138 for _, override := range c.EtcdServersOverrides { 139 tokens := strings.Split(override, "#") 140 apiresource := strings.Split(tokens[0], "/") 141 142 group := apiresource[0] 143 resource := apiresource[1] 144 groupResource := schema.GroupResource{Group: group, Resource: resource} 145 146 servers := strings.Split(tokens[1], ";") 147 storageFactory.SetEtcdLocation(groupResource, servers) 148 } 149 return storageFactory, nil 150 }