Debian Codegraph @

pkg/server/resourceconfig/helpers.go

raw
1 /*
2 Copyright 2017 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 resourceconfig
18
19 import (
20 "fmt"
21 "regexp"
22 "sort"
23 "strconv"
24 "strings"
25
26 "k8s.io/apimachinery/pkg/runtime"
27 "k8s.io/apimachinery/pkg/runtime/schema"
28 "k8s.io/apimachinery/pkg/version"
29 serverstore "k8s.io/apiserver/pkg/server/storage"
30 cliflag "k8s.io/component-base/cli/flag"
31 )
32
33 // GroupVersionRegistry provides access to registered group versions.
34 type GroupVersionRegistry interface {
35 // IsGroupRegistered returns true if given group is registered.
36 IsGroupRegistered(group string) bool
37 // IsVersionRegistered returns true if given version is registered.
38 IsVersionRegistered(v schema.GroupVersion) bool
39 // PrioritizedVersionsAllGroups returns all registered group versions.
40 PrioritizedVersionsAllGroups() []schema.GroupVersion
41 // PrioritizedVersionsForGroup returns versions for a single group in priority order
42 PrioritizedVersionsForGroup(group string) []schema.GroupVersion
43 }
44
45 // MergeResourceEncodingConfigs merges the given defaultResourceConfig with specific GroupVersionResource overrides.
46 func MergeResourceEncodingConfigs(
47 defaultResourceEncoding *serverstore.DefaultResourceEncodingConfig,
48 resourceEncodingOverrides []schema.GroupVersionResource,
49 ) *serverstore.DefaultResourceEncodingConfig {
50 resourceEncodingConfig := defaultResourceEncoding
51 for _, gvr := range resourceEncodingOverrides {
52 resourceEncodingConfig.SetResourceEncoding(gvr.GroupResource(), gvr.GroupVersion(),
53 schema.GroupVersion{Group: gvr.Group, Version: runtime.APIVersionInternal})
54 }
55 return resourceEncodingConfig
56 }
57
58 // Recognized values for the --runtime-config parameter to enable/disable groups of APIs
59 const (
60 APIAll = "api/all"
61 APIGA = "api/ga"
62 APIBeta = "api/beta"
63 APIAlpha = "api/alpha"
64 )
65
66 var (
67 gaPattern = regexp.MustCompile(`^v\d+$`)
68 betaPattern = regexp.MustCompile(`^v\d+beta\d+$`)
69 alphaPattern = regexp.MustCompile(`^v\d+alpha\d+$`)
70
71 groupVersionMatchers = map[string]func(gv schema.GroupVersion) bool{
72 // allows users to address all api versions
73 APIAll: func(gv schema.GroupVersion) bool { return true },
74 // allows users to address all api versions in the form v[0-9]+
75 APIGA: func(gv schema.GroupVersion) bool { return gaPattern.MatchString(gv.Version) },
76 // allows users to address all beta api versions
77 APIBeta: func(gv schema.GroupVersion) bool { return betaPattern.MatchString(gv.Version) },
78 // allows users to address all alpha api versions
79 APIAlpha: func(gv schema.GroupVersion) bool { return alphaPattern.MatchString(gv.Version) },
80 }
81
82 groupVersionMatchersOrder = []string{APIAll, APIGA, APIBeta, APIAlpha}
83 )
84
85 // MergeAPIResourceConfigs merges the given defaultAPIResourceConfig with the given resourceConfigOverrides.
86 // Exclude the groups not registered in registry, and check if version is
87 // not registered in group, then it will fail.
88 func MergeAPIResourceConfigs(
89 defaultAPIResourceConfig *serverstore.ResourceConfig,
90 resourceConfigOverrides cliflag.ConfigurationMap,
91 registry GroupVersionRegistry,
92 ) (*serverstore.ResourceConfig, error) {
93 resourceConfig := defaultAPIResourceConfig
94 overrides := resourceConfigOverrides
95
96 for _, flag := range groupVersionMatchersOrder {
97 if value, ok := overrides[flag]; ok {
98 if value == "false" {
99 resourceConfig.DisableMatchingVersions(groupVersionMatchers[flag])
100 } else if value == "true" {
101 resourceConfig.EnableMatchingVersions(groupVersionMatchers[flag])
102 } else {
103 return nil, fmt.Errorf("invalid value %v=%v", flag, value)
104 }
105 }
106 }
107 if err := applyVersionAndResourcePreferences(resourceConfig, overrides, registry); err != nil {
108 return nil, err
109 }
110 return resourceConfig, nil
111 }
112
113 func applyVersionAndResourcePreferences(
114 resourceConfig *serverstore.ResourceConfig,
115 overrides cliflag.ConfigurationMap,
116 registry GroupVersionRegistry,
117 ) error {
118 type versionEnablementPreference struct {
119 key string
120 enabled bool
121 groupVersion schema.GroupVersion
122 }
123 type resourceEnablementPreference struct {
124 key string
125 enabled bool
126 groupVersionResource schema.GroupVersionResource
127 }
128 versionPreferences := []versionEnablementPreference{}
129 resourcePreferences := []resourceEnablementPreference{}
130
131 // "<resourceSpecifier>={true|false} allows users to enable/disable API.
132 // This takes preference over api/all, if specified.
133 // Iterate through all group/version overrides specified in runtimeConfig.
134 for key := range overrides {
135 // Have already handled them above. Can skip them here.
136 if _, ok := groupVersionMatchers[key]; ok {
137 continue
138 }
139
140 tokens := strings.Split(key, "/")
141 if len(tokens) < 2 || len(tokens) > 3 {
142 continue
143 }
144 groupVersionString := tokens[0] + "/" + tokens[1]
145 groupVersion, err := schema.ParseGroupVersion(groupVersionString)
146 if err != nil {
147 return fmt.Errorf("invalid key %s", key)
148 }
149
150 // Exclude group not registered into the registry.
151 if !registry.IsGroupRegistered(groupVersion.Group) {
152 continue
153 }
154
155 // Verify that the groupVersion is registered into registry.
156 if !registry.IsVersionRegistered(groupVersion) {
157 return fmt.Errorf("group version %s that has not been registered", groupVersion.String())
158 }
159 enabled, err := getRuntimeConfigValue(overrides, key, false)
160 if err != nil {
161 return err
162 }
163
164 switch len(tokens) {
165 case 2:
166 versionPreferences = append(versionPreferences, versionEnablementPreference{
167 key: key,
168 enabled: enabled,
169 groupVersion: groupVersion,
170 })
171 case 3:
172 if strings.ToLower(tokens[2]) != tokens[2] {
173 return fmt.Errorf("invalid key %v: group/version/resource and resource is always lowercase plural, not %q", key, tokens[2])
174 }
175 resourcePreferences = append(resourcePreferences, resourceEnablementPreference{
176 key: key,
177 enabled: enabled,
178 groupVersionResource: groupVersion.WithResource(tokens[2]),
179 })
180 }
181 }
182
183 // apply version preferences first, so that we can remove the hardcoded resource preferences that are being overridden
184 for _, versionPreference := range versionPreferences {
185 if versionPreference.enabled {
186 // enable the groupVersion for "group/version=true"
187 resourceConfig.ExplicitlyEnableVersions(versionPreference.groupVersion)
188
189 } else {
190 // disable the groupVersion only for "group/version=false"
191 resourceConfig.ExplicitlyDisableVersions(versionPreference.groupVersion)
192 }
193 }
194
195 // apply resource preferences last, so they have the highest priority
196 for _, resourcePreference := range resourcePreferences {
197 if resourcePreference.enabled {
198 // enable the resource for "group/version/resource=true"
199 resourceConfig.ExplicitlyEnableResources(resourcePreference.groupVersionResource)
200 } else {
201 resourceConfig.ExplicitlyDisableResources(resourcePreference.groupVersionResource)
202 }
203 }
204 return nil
205 }
206
207 func getRuntimeConfigValue(overrides cliflag.ConfigurationMap, apiKey string, defaultValue bool) (bool, error) {
208 flagValue, ok := overrides[apiKey]
209 if ok {
210 if flagValue == "" {
211 return true, nil
212 }
213 boolValue, err := strconv.ParseBool(flagValue)
214 if err != nil {
215 return false, fmt.Errorf("invalid value of %s: %s, err: %v", apiKey, flagValue, err)
216 }
217 return boolValue, nil
218 }
219 return defaultValue, nil
220 }
221
222 // ParseGroups takes in resourceConfig and returns parsed groups.
223 func ParseGroups(resourceConfig cliflag.ConfigurationMap) ([]string, error) {
224 groups := []string{}
225 for key := range resourceConfig {
226 if _, ok := groupVersionMatchers[key]; ok {
227 continue
228 }
229 tokens := strings.Split(key, "/")
230 if len(tokens) != 2 && len(tokens) != 3 {
231 return groups, fmt.Errorf("runtime-config invalid key %s", key)
232 }
233 groupVersionString := tokens[0] + "/" + tokens[1]
234 groupVersion, err := schema.ParseGroupVersion(groupVersionString)
235 if err != nil {
236 return nil, fmt.Errorf("runtime-config invalid key %s", key)
237 }
238 groups = append(groups, groupVersion.Group)
239 }
240
241 return groups, nil
242 }
243
244 // EmulationForwardCompatibleResourceConfig creates a new ResourceConfig that besides all the enabled resources in resourceConfig,
245 // enables all higher priority versions of enabled resources, excluding alpha versions.
246 // This is useful for ensuring forward compatibility when a new version of an API is introduced.
247 func EmulationForwardCompatibleResourceConfig(
248 resourceConfig *serverstore.ResourceConfig,
249 resourceConfigOverrides cliflag.ConfigurationMap,
250 registry GroupVersionRegistry,
251 ) (*serverstore.ResourceConfig, error) {
252 ret := serverstore.NewResourceConfig()
253 for gv, enabled := range resourceConfig.GroupVersionConfigs {
254 ret.GroupVersionConfigs[gv] = enabled
255 if !enabled {
256 continue
257 }
258 // emulation forward compatibility is not applicable to alpha apis.
259 if alphaPattern.MatchString(gv.Version) {
260 continue
261 }
262 // if a gv is enabled, all the versions with higher priority (all the versions before gv in PrioritizedVersionsForGroup) are also implicitly enabled for emulation forward compatibility.
263 prioritizedVersions := registry.PrioritizedVersionsForGroup(gv.Group)
264 sort.Slice(prioritizedVersions, func(i, j int) bool {
265 return version.CompareKubeAwareVersionStrings(prioritizedVersions[i].Version, prioritizedVersions[j].Version) > 0
266 })
267 for _, pgv := range prioritizedVersions {
268 if pgv.Version == gv.Version {
269 break
270 }
271 ret.EnableVersions(pgv)
272 }
273 }
274 for gvr, enabled := range resourceConfig.ResourceConfigs {
275 ret.ResourceConfigs[gvr] = enabled
276 if !enabled {
277 continue
278 }
279 // emulation forward compatibility is not applicable to alpha apis.
280 if alphaPattern.MatchString(gvr.Version) {
281 continue
282 }
283 // if a gvr is enabled, all the versions with the same resource name and higher priority (all the versions before gv in PrioritizedVersionsForGroup) are also implicitly enabled for emulation forward compatibility.
284 prioritizedVersions := registry.PrioritizedVersionsForGroup(gvr.Group)
285 sort.Slice(prioritizedVersions, func(i, j int) bool {
286 return version.CompareKubeAwareVersionStrings(prioritizedVersions[i].Version, prioritizedVersions[j].Version) > 0
287 })
288 for _, pgv := range prioritizedVersions {
289 if pgv.Version == gvr.Version {
290 break
291 }
292 ret.EnableResources(pgv.WithResource(gvr.Resource))
293 }
294 }
295 // need to reapply the version preferences if there is an override of a higher priority version.
296 if err := applyVersionAndResourcePreferences(ret, resourceConfigOverrides, registry); err != nil {
297 return nil, err
298 }
299 return ret, nil
300 }