Debian Codegraph @

pkg/registry/generic/registry/corrupt_obj_deleter_test.go

raw
1 /*
2 Copyright 2024 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 registry
18
19 import (
20 "context"
21 "fmt"
22 "strings"
23 "testing"
24
25 "k8s.io/apimachinery/pkg/api/errors"
26 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
27 "k8s.io/apimachinery/pkg/runtime"
28 "k8s.io/apiserver/pkg/apis/example"
29 genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
30 "k8s.io/apiserver/pkg/registry/rest"
31 "k8s.io/apiserver/pkg/storage"
32
33 "k8s.io/utils/ptr"
34 )
35
36 type result struct {
37 deleted bool
38 err error
39 }
40
41 type deleteWant struct {
42 deleted bool
43 checkErr func(err error) bool
44 }
45
46 var (
47 wantNoError = func(err error) bool { return err == nil }
48 wantErrContains = func(shouldContain string) func(error) bool {
49 return func(err error) bool {
50 return err != nil && strings.Contains(err.Error(), shouldContain)
51 }
52 }
53 )
54
55 func (w deleteWant) verify(t *testing.T, got result) {
56 t.Helper()
57
58 if !w.checkErr(got.err) {
59 t.Errorf("Unexpected failure with the deletion operation, got: %v", got.err)
60 }
61 if w.deleted != got.deleted {
62 t.Errorf("Expected deleted to be: %t, but got: %t", w.deleted, got.deleted)
63 }
64
65 }
66
67 func TestUnsafeDeletePrecondition(t *testing.T) {
68 option := func(enabled bool) *metav1.DeleteOptions {
69 return &metav1.DeleteOptions{
70 IgnoreStoreReadErrorWithClusterBreakingPotential: ptr.To[bool](enabled),
71 }
72 }
73
74 const (
75 unsafeDeleteNotAllowed = "ignoreStoreReadErrorWithClusterBreakingPotential: Invalid value: true: is exclusively used to delete corrupt object(s), try again by removing this option"
76 internalErr = "Internal error occurred: initialization error, expected normal deletion flow to be used"
77 )
78
79 tests := []struct {
80 name string
81 err error
82 opts *metav1.DeleteOptions
83 invoked int
84 want deleteWant
85 }{
86 {
87 name: "option nil, should throw internal error",
88 opts: nil,
89 want: deleteWant{checkErr: wantErrContains(internalErr)},
90 },
91 {
92 name: "option empty, should throw internal error",
93 opts: &metav1.DeleteOptions{},
94 want: deleteWant{checkErr: wantErrContains(internalErr)},
95 },
96 {
97 name: "option false, should throw internal error",
98 opts: option(false),
99 want: deleteWant{checkErr: wantErrContains(internalErr)},
100 },
101 {
102 name: "option true, object readable, should throw invalid error",
103 opts: option(true),
104 want: deleteWant{
105 checkErr: wantErrContains(unsafeDeleteNotAllowed),
106 },
107 },
108 {
109 name: "option true, object not readable with unexpected error, should throw invalid error",
110 opts: option(true),
111 err: fmt.Errorf("unexpected error"),
112 want: deleteWant{
113 checkErr: wantErrContains(unsafeDeleteNotAllowed),
114 },
115 },
116 {
117 name: "option true, object not readable with storage internal error, should throw invalid error",
118 opts: option(true),
119 err: storage.NewInternalError(fmt.Errorf("unexpected error")),
120 want: deleteWant{
121 checkErr: wantErrContains(unsafeDeleteNotAllowed),
122 },
123 },
124 {
125 name: "option true, object not readable with corrupt object error, unsafe-delete should trigger",
126 opts: option(true),
127 err: storage.NewCorruptObjError("foo", fmt.Errorf("object not decodable")),
128 want: deleteWant{
129 deleted: true,
130 checkErr: wantNoError,
131 },
132 invoked: 1,
133 },
134 }
135
136 for _, test := range tests {
137 t.Run(test.name, func(t *testing.T) {
138 ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), "test")
139 destroyFunc, registry := NewTestGenericStoreRegistry(t)
140 defer destroyFunc()
141
142 object := &example.Pod{
143 ObjectMeta: metav1.ObjectMeta{Name: "foo"},
144 Spec: example.PodSpec{NodeName: "machine"},
145 }
146 _, err := registry.Create(ctx, object, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
147 if err != nil {
148 t.Fatalf("Unexpected error from Create: %v", err)
149 }
150
151 // wrap the storage so it returns the expected error
152 cs := &corruptStorage{
153 Interface: registry.Storage.Storage,
154 err: test.err,
155 }
156 registry.Storage.Storage = cs
157 deleter := NewCorruptObjectDeleter(registry)
158
159 _, deleted, err := deleter.Delete(ctx, "foo", rest.ValidateAllObjectFunc, test.opts)
160
161 got := result{deleted: deleted, err: err}
162 test.want.verify(t, got)
163 if want, got := test.invoked, cs.unsafeDeleteInvoked; want != got {
164 t.Errorf("Expected unsafe-delete to be invoked %d time(s), but got: %d", want, got)
165 }
166 })
167 }
168 }
169
170 func TestUnsafeDeleteWithCorruptObject(t *testing.T) {
171 ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), "test")
172 destroyFunc, registry := NewTestGenericStoreRegistry(t)
173 defer destroyFunc()
174
175 object := &example.Pod{
176 ObjectMeta: metav1.ObjectMeta{Name: "foo"},
177 Spec: example.PodSpec{NodeName: "machine"},
178 }
179 // a) prerequisite: try deleting the object, we expect a not found error
180 _, _, err := registry.Delete(ctx, object.Name, rest.ValidateAllObjectFunc, nil)
181 if !errors.IsNotFound(err) {
182 t.Errorf("Unexpected error: %v", err)
183 }
184
185 // b) create the target object
186 _, err = registry.Create(ctx, object, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
187 if err != nil {
188 t.Errorf("Unexpected error: %v", err)
189 }
190
191 // c) wrap the storage to return corrupt object error
192 cs := &corruptStorage{
193 Interface: registry.Storage.Storage,
194 err: storage.NewCorruptObjError("key", fmt.Errorf("untransformable")),
195 }
196 registry.Storage.Storage = cs
197
198 got := result{}
199 // d) try deleting the traget object
200 _, got.deleted, got.err = registry.Delete(ctx, object.Name, rest.ValidateAllObjectFunc, nil)
201 want := deleteWant{checkErr: errors.IsInternalError}
202 want.verify(t, got)
203
204 // e) set up an unsafe-deleter
205 deleter := NewCorruptObjectDeleter(registry)
206
207 // f) try to delete the object, but don't set the delete option just yet
208 _, got.deleted, got.err = deleter.Delete(ctx, object.Name, rest.ValidateAllObjectFunc, nil)
209 want.verify(t, got)
210
211 // g) this time, set the delete option to ignore store read error
212 _, got.deleted, got.err = deleter.Delete(ctx, object.Name, rest.ValidateAllObjectFunc, &metav1.DeleteOptions{
213 IgnoreStoreReadErrorWithClusterBreakingPotential: ptr.To[bool](true),
214 })
215 want = deleteWant{
216 deleted: true,
217 checkErr: wantNoError,
218 }
219 want.verify(t, got)
220 if want, got := 1, cs.unsafeDeleteInvoked; want != got {
221 t.Errorf("Expected unsafe-delete to be invoked %d time(s), but got: %d", want, got)
222 }
223 }
224
225 func TestUnsafeDeleteWithUnexpectedError(t *testing.T) {
226 ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), "test")
227 // TODO: inject a corrupt transformer
228 destroyFunc, registry := NewTestGenericStoreRegistry(t)
229 defer destroyFunc()
230
231 object := &example.Pod{
232 ObjectMeta: metav1.ObjectMeta{Name: "foo"},
233 Spec: example.PodSpec{NodeName: "machine"},
234 }
235 // a) create the target object
236 _, err := registry.Create(ctx, object, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
237 if err != nil {
238 t.Fatalf("Unexpected error: %v", err)
239 }
240
241 // b) wrap the storage to return corrupt object error
242 cs := &corruptStorage{
243 Interface: registry.Storage.Storage,
244 err: storage.NewInternalError(fmt.Errorf("unexpected error")),
245 }
246 registry.Storage.Storage = cs
247
248 // c) try deleting the object using normal deletion flow
249 got := result{}
250 _, got.deleted, got.err = registry.Delete(ctx, object.Name, rest.ValidateAllObjectFunc, nil)
251 want := deleteWant{checkErr: errors.IsInternalError}
252 want.verify(t, got)
253
254 // d) set up a corrupt object deleter for the registry
255 deleter := NewCorruptObjectDeleter(registry)
256
257 // e) try deleting with unsafe-delete
258 _, got.deleted, got.err = deleter.Delete(ctx, object.Name, rest.ValidateAllObjectFunc, &metav1.DeleteOptions{
259 IgnoreStoreReadErrorWithClusterBreakingPotential: ptr.To[bool](true),
260 })
261 want = deleteWant{
262 checkErr: wantErrContains("is exclusively used to delete corrupt object(s), try again by removing this option"),
263 }
264 want.verify(t, got)
265 if want, got := 0, cs.unsafeDeleteInvoked; want != got {
266 t.Errorf("Expected unsafe-delete to be invoked %d time(s), but got: %d", want, got)
267 }
268 }
269
270 func TestUnsafeDeleteWithAdmissionShouldBeSkipped(t *testing.T) {
271 ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), "test")
272 destroyFunc, registry := NewTestGenericStoreRegistry(t)
273 defer destroyFunc()
274
275 // a) create the target object
276 object := &example.Pod{
277 ObjectMeta: metav1.ObjectMeta{Name: "foo"},
278 Spec: example.PodSpec{NodeName: "machine"},
279 }
280 _, err := registry.Create(ctx, object, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
281 if err != nil {
282 t.Fatalf("Unexpected error: %v", err)
283 }
284
285 // b) wrap the storage layer to return corrupt object error
286 registry.Storage.Storage = &corruptStorage{
287 Interface: registry.Storage.Storage,
288 err: storage.NewCorruptObjError("key", fmt.Errorf("untransformable")),
289 }
290
291 // c) set up a corrupt object deleter for the registry
292 deleter := NewCorruptObjectDeleter(registry)
293
294 // d) try unsafe delete, but pass a validation that always fails
295 var admissionInvoked int
296 _, deleted, err := deleter.Delete(ctx, object.Name, func(_ context.Context, _ runtime.Object) error {
297 admissionInvoked++
298 return fmt.Errorf("admission was not skipped")
299 }, &metav1.DeleteOptions{
300 IgnoreStoreReadErrorWithClusterBreakingPotential: ptr.To[bool](true),
301 })
302
303 if err != nil {
304 t.Errorf("Unexpected error from Delete: %v", err)
305 }
306 if want, got := true, deleted; want != got {
307 t.Errorf("Expected deleted: %t, but got: %t", want, got)
308 }
309 if want, got := 0, admissionInvoked; want != got {
310 t.Errorf("Expected admission to be invoked %d time(s), but got: %d", want, got)
311 }
312 }
313
314 type corruptStorage struct {
315 storage.Interface
316 err error
317 unsafeDeleteInvoked int
318 }
319
320 func (s *corruptStorage) Get(ctx context.Context, key string, opts storage.GetOptions, objPtr runtime.Object) error {
321 if s.err != nil {
322 return s.err
323 }
324 return s.Interface.Get(ctx, key, opts, objPtr)
325 }
326
327 func (s *corruptStorage) Delete(ctx context.Context, key string, out runtime.Object, preconditions *storage.Preconditions, deleteValidation storage.ValidateObjectFunc, cachedExistingObject runtime.Object, opts storage.DeleteOptions) error {
328 if opts.IgnoreStoreReadError {
329 s.unsafeDeleteInvoked++
330 }
331 return s.Interface.Delete(ctx, key, out, preconditions, deleteValidation, cachedExistingObject, opts)
332 }