Debian Codegraph @

util/csaupgrade/upgrade.go

raw
1 /*
2 Copyright 2022 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 csaupgrade
18
19 import (
20 "bytes"
21 "encoding/json"
22 "errors"
23 "fmt"
24 "reflect"
25
26 "k8s.io/apimachinery/pkg/api/meta"
27 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
28 "k8s.io/apimachinery/pkg/runtime"
29 "k8s.io/apimachinery/pkg/util/sets"
30 "sigs.k8s.io/structured-merge-diff/v4/fieldpath"
31 )
32
33 // Finds all managed fields owners of the given operation type which owns all of
34 // the fields in the given set
35 //
36 // If there is an error decoding one of the fieldsets for any reason, it is ignored
37 // and assumed not to match the query.
38 func FindFieldsOwners(
39 managedFields []metav1.ManagedFieldsEntry,
40 operation metav1.ManagedFieldsOperationType,
41 fields *fieldpath.Set,
42 ) []metav1.ManagedFieldsEntry {
43 var result []metav1.ManagedFieldsEntry
44 for _, entry := range managedFields {
45 if entry.Operation != operation {
46 continue
47 }
48
49 fieldSet, err := decodeManagedFieldsEntrySet(entry)
50 if err != nil {
51 continue
52 }
53
54 if fields.Difference(&fieldSet).Empty() {
55 result = append(result, entry)
56 }
57 }
58 return result
59 }
60
61 // Upgrades the Manager information for fields managed with client-side-apply (CSA)
62 // Prepares fields owned by `csaManager` for 'Update' operations for use now
63 // with the given `ssaManager` for `Apply` operations.
64 //
65 // This transformation should be performed on an object if it has been previously
66 // managed using client-side-apply to prepare it for future use with
67 // server-side-apply.
68 //
69 // Caveats:
70 // 1. This operation is not reversible. Information about which fields the client
71 // owned will be lost in this operation.
72 // 2. Supports being performed either before or after initial server-side apply.
73 // 3. Client-side apply tends to own more fields (including fields that are defaulted),
74 // this will possibly remove this defaults, they will be re-defaulted, that's fine.
75 // 4. Care must be taken to not overwrite the managed fields on the server if they
76 // have changed before sending a patch.
77 //
78 // obj - Target of the operation which has been managed with CSA in the past
79 // csaManagerNames - Names of FieldManagers to merge into ssaManagerName
80 // ssaManagerName - Name of FieldManager to be used for `Apply` operations
81 func UpgradeManagedFields(
82 obj runtime.Object,
83 csaManagerNames sets.Set[string],
84 ssaManagerName string,
85 opts ...Option,
86 ) error {
87 o := options{}
88 for _, opt := range opts {
89 opt(&o)
90 }
91
92 accessor, err := meta.Accessor(obj)
93 if err != nil {
94 return err
95 }
96
97 filteredManagers := accessor.GetManagedFields()
98
99 for csaManagerName := range csaManagerNames {
100 filteredManagers, err = upgradedManagedFields(
101 filteredManagers, csaManagerName, ssaManagerName, o)
102
103 if err != nil {
104 return err
105 }
106 }
107
108 // Commit changes to object
109 accessor.SetManagedFields(filteredManagers)
110 return nil
111 }
112
113 // Calculates a minimal JSON Patch to send to upgrade managed fields
114 // See `UpgradeManagedFields` for more information.
115 //
116 // obj - Target of the operation which has been managed with CSA in the past
117 // csaManagerNames - Names of FieldManagers to merge into ssaManagerName
118 // ssaManagerName - Name of FieldManager to be used for `Apply` operations
119 //
120 // Returns non-nil error if there was an error, a JSON patch, or nil bytes if
121 // there is no work to be done.
122 func UpgradeManagedFieldsPatch(
123 obj runtime.Object,
124 csaManagerNames sets.Set[string],
125 ssaManagerName string,
126 opts ...Option,
127 ) ([]byte, error) {
128 o := options{}
129 for _, opt := range opts {
130 opt(&o)
131 }
132
133 accessor, err := meta.Accessor(obj)
134 if err != nil {
135 return nil, err
136 }
137
138 managedFields := accessor.GetManagedFields()
139 filteredManagers := accessor.GetManagedFields()
140 for csaManagerName := range csaManagerNames {
141 filteredManagers, err = upgradedManagedFields(
142 filteredManagers, csaManagerName, ssaManagerName, o)
143 if err != nil {
144 return nil, err
145 }
146 }
147
148 if reflect.DeepEqual(managedFields, filteredManagers) {
149 // If the managed fields have not changed from the transformed version,
150 // there is no patch to perform
151 return nil, nil
152 }
153
154 // Create a patch with a diff between old and new objects.
155 // Just include all managed fields since that is only thing that will change
156 //
157 // Also include test for RV to avoid race condition
158 jsonPatch := []map[string]interface{}{
159 {
160 "op": "replace",
161 "path": "/metadata/managedFields",
162 "value": filteredManagers,
163 },
164 {
165 // Use "replace" instead of "test" operation so that etcd rejects with
166 // 409 conflict instead of apiserver with an invalid request
167 "op": "replace",
168 "path": "/metadata/resourceVersion",
169 "value": accessor.GetResourceVersion(),
170 },
171 }
172
173 return json.Marshal(jsonPatch)
174 }
175
176 // Returns a copy of the provided managed fields that has been migrated from
177 // client-side-apply to server-side-apply, or an error if there was an issue
178 func upgradedManagedFields(
179 managedFields []metav1.ManagedFieldsEntry,
180 csaManagerName string,
181 ssaManagerName string,
182 opts options,
183 ) ([]metav1.ManagedFieldsEntry, error) {
184 if managedFields == nil {
185 return nil, nil
186 }
187
188 // Create managed fields clone since we modify the values
189 managedFieldsCopy := make([]metav1.ManagedFieldsEntry, len(managedFields))
190 if copy(managedFieldsCopy, managedFields) != len(managedFields) {
191 return nil, errors.New("failed to copy managed fields")
192 }
193 managedFields = managedFieldsCopy
194
195 // Locate SSA manager
196 replaceIndex, managerExists := findFirstIndex(managedFields,
197 func(entry metav1.ManagedFieldsEntry) bool {
198 return entry.Manager == ssaManagerName &&
199 entry.Operation == metav1.ManagedFieldsOperationApply &&
200 entry.Subresource == opts.subresource
201 })
202
203 if !managerExists {
204 // SSA manager does not exist. Find the most recent matching CSA manager,
205 // convert it to an SSA manager.
206 //
207 // (find first index, since managed fields are sorted so that most recent is
208 // first in the list)
209 replaceIndex, managerExists = findFirstIndex(managedFields,
210 func(entry metav1.ManagedFieldsEntry) bool {
211 return entry.Manager == csaManagerName &&
212 entry.Operation == metav1.ManagedFieldsOperationUpdate &&
213 entry.Subresource == opts.subresource
214 })
215
216 if !managerExists {
217 // There are no CSA managers that need to be converted. Nothing to do
218 // Return early
219 return managedFields, nil
220 }
221
222 // Convert CSA manager into SSA manager
223 managedFields[replaceIndex].Operation = metav1.ManagedFieldsOperationApply
224 managedFields[replaceIndex].Manager = ssaManagerName
225 }
226 err := unionManagerIntoIndex(managedFields, replaceIndex, csaManagerName, opts)
227 if err != nil {
228 return nil, err
229 }
230
231 // Create version of managed fields which has no CSA managers with the given name
232 filteredManagers := filter(managedFields, func(entry metav1.ManagedFieldsEntry) bool {
233 return !(entry.Manager == csaManagerName &&
234 entry.Operation == metav1.ManagedFieldsOperationUpdate &&
235 entry.Subresource == opts.subresource)
236 })
237
238 return filteredManagers, nil
239 }
240
241 // Locates an Update manager entry named `csaManagerName` with the same APIVersion
242 // as the manager at the targetIndex. Unions both manager's fields together
243 // into the manager specified by `targetIndex`. No other managers are modified.
244 func unionManagerIntoIndex(
245 entries []metav1.ManagedFieldsEntry,
246 targetIndex int,
247 csaManagerName string,
248 opts options,
249 ) error {
250 ssaManager := entries[targetIndex]
251
252 // find Update manager of same APIVersion, union ssa fields with it.
253 // discard all other Update managers of the same name
254 csaManagerIndex, csaManagerExists := findFirstIndex(entries,
255 func(entry metav1.ManagedFieldsEntry) bool {
256 return entry.Manager == csaManagerName &&
257 entry.Operation == metav1.ManagedFieldsOperationUpdate &&
258 entry.Subresource == opts.subresource &&
259 entry.APIVersion == ssaManager.APIVersion
260 })
261
262 targetFieldSet, err := decodeManagedFieldsEntrySet(ssaManager)
263 if err != nil {
264 return fmt.Errorf("failed to convert fields to set: %w", err)
265 }
266
267 combinedFieldSet := &targetFieldSet
268
269 // Union the csa manager with the existing SSA manager. Do nothing if
270 // there was no good candidate found
271 if csaManagerExists {
272 csaManager := entries[csaManagerIndex]
273
274 csaFieldSet, err := decodeManagedFieldsEntrySet(csaManager)
275 if err != nil {
276 return fmt.Errorf("failed to convert fields to set: %w", err)
277 }
278
279 combinedFieldSet = combinedFieldSet.Union(&csaFieldSet)
280 }
281
282 // Encode the fields back to the serialized format
283 err = encodeManagedFieldsEntrySet(&entries[targetIndex], *combinedFieldSet)
284 if err != nil {
285 return fmt.Errorf("failed to encode field set: %w", err)
286 }
287
288 return nil
289 }
290
291 func findFirstIndex[T any](
292 collection []T,
293 predicate func(T) bool,
294 ) (int, bool) {
295 for idx, entry := range collection {
296 if predicate(entry) {
297 return idx, true
298 }
299 }
300
301 return -1, false
302 }
303
304 func filter[T any](
305 collection []T,
306 predicate func(T) bool,
307 ) []T {
308 result := make([]T, 0, len(collection))
309
310 for _, value := range collection {
311 if predicate(value) {
312 result = append(result, value)
313 }
314 }
315
316 if len(result) == 0 {
317 return nil
318 }
319
320 return result
321 }
322
323 // Included from fieldmanager.internal to avoid dependency cycle
324 // FieldsToSet creates a set paths from an input trie of fields
325 func decodeManagedFieldsEntrySet(f metav1.ManagedFieldsEntry) (s fieldpath.Set, err error) {
326 err = s.FromJSON(bytes.NewReader(f.FieldsV1.Raw))
327 return s, err
328 }
329
330 // SetToFields creates a trie of fields from an input set of paths
331 func encodeManagedFieldsEntrySet(f *metav1.ManagedFieldsEntry, s fieldpath.Set) (err error) {
332 f.FieldsV1.Raw, err = s.ToJSON()
333 return err
334 }