Debian Codegraph @

pkg/endpoints/handlers/create.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 handlers
18
19 import (
20 "bytes"
21 "context"
22 "fmt"
23 "net/http"
24 "strings"
25 "time"
26 "unicode"
27 "unicode/utf8"
28
29 "go.opentelemetry.io/otel/attribute"
30
31 "k8s.io/apimachinery/pkg/api/errors"
32 "k8s.io/apimachinery/pkg/api/meta"
33 metainternalversionscheme "k8s.io/apimachinery/pkg/apis/meta/internalversion/scheme"
34 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
35 "k8s.io/apimachinery/pkg/apis/meta/v1/validation"
36 "k8s.io/apimachinery/pkg/runtime"
37 "k8s.io/apimachinery/pkg/runtime/schema"
38 "k8s.io/apiserver/pkg/admission"
39 "k8s.io/apiserver/pkg/audit"
40 "k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager"
41 "k8s.io/apiserver/pkg/endpoints/handlers/finisher"
42 requestmetrics "k8s.io/apiserver/pkg/endpoints/handlers/metrics"
43 "k8s.io/apiserver/pkg/endpoints/handlers/negotiation"
44 "k8s.io/apiserver/pkg/endpoints/request"
45 "k8s.io/apiserver/pkg/registry/rest"
46 "k8s.io/apiserver/pkg/util/dryrun"
47 "k8s.io/component-base/tracing"
48 "k8s.io/klog/v2"
49 )
50
51 var namespaceGVR = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "namespaces"}
52
53 func createHandler(r rest.NamedCreater, scope *RequestScope, admit admission.Interface, includeName bool) http.HandlerFunc {
54 return func(w http.ResponseWriter, req *http.Request) {
55 ctx := req.Context()
56 // For performance tracking purposes.
57 ctx, span := tracing.Start(ctx, "Create", traceFields(req)...)
58 req = req.WithContext(ctx)
59 defer span.End(500 * time.Millisecond)
60
61 namespace, name, err := scope.Namer.Name(req)
62 if err != nil {
63 if includeName {
64 // name was required, return
65 scope.err(err, w, req)
66 return
67 }
68
69 // otherwise attempt to look up the namespace
70 namespace, err = scope.Namer.Namespace(req)
71 if err != nil {
72 scope.err(err, w, req)
73 return
74 }
75 }
76
77 // enforce a timeout of at most requestTimeoutUpperBound (34s) or less if the user-provided
78 // timeout inside the parent context is lower than requestTimeoutUpperBound.
79 ctx, cancel := context.WithTimeout(ctx, requestTimeoutUpperBound)
80 defer cancel()
81 outputMediaType, _, err := negotiation.NegotiateOutputMediaType(req, scope.Serializer, scope)
82 if err != nil {
83 scope.err(err, w, req)
84 return
85 }
86
87 gv := scope.Kind.GroupVersion()
88 s, err := negotiation.NegotiateInputSerializer(req, false, scope.Serializer)
89 if err != nil {
90 scope.err(err, w, req)
91 return
92 }
93
94 body, err := limitedReadBodyWithRecordMetric(ctx, req, scope.MaxRequestBodyBytes, scope.Resource.GroupResource().String(), requestmetrics.Create)
95 if err != nil {
96 span.AddEvent("limitedReadBody failed", attribute.Int("len", len(body)), attribute.String("err", err.Error()))
97 scope.err(err, w, req)
98 return
99 }
100 span.AddEvent("limitedReadBody succeeded", attribute.Int("len", len(body)))
101
102 options := &metav1.CreateOptions{}
103 values := req.URL.Query()
104 if err := metainternalversionscheme.ParameterCodec.DecodeParameters(values, scope.MetaGroupVersion, options); err != nil {
105 err = errors.NewBadRequest(err.Error())
106 scope.err(err, w, req)
107 return
108 }
109 if errs := validation.ValidateCreateOptions(options); len(errs) > 0 {
110 err := errors.NewInvalid(schema.GroupKind{Group: metav1.GroupName, Kind: "CreateOptions"}, "", errs)
111 scope.err(err, w, req)
112 return
113 }
114 options.TypeMeta.SetGroupVersionKind(metav1.SchemeGroupVersion.WithKind("CreateOptions"))
115
116 defaultGVK := scope.Kind
117 original := r.New()
118
119 validationDirective := fieldValidation(options.FieldValidation)
120 decodeSerializer := s.Serializer
121 if validationDirective == metav1.FieldValidationWarn || validationDirective == metav1.FieldValidationStrict {
122 decodeSerializer = s.StrictSerializer
123 }
124
125 decoder := scope.Serializer.DecoderToVersion(decodeSerializer, scope.HubGroupVersion)
126 span.AddEvent("About to convert to expected version")
127 obj, gvk, err := decoder.Decode(body, &defaultGVK, original)
128 if err != nil {
129 strictError, isStrictError := runtime.AsStrictDecodingError(err)
130 switch {
131 case isStrictError && obj != nil && validationDirective == metav1.FieldValidationWarn:
132 addStrictDecodingWarnings(req.Context(), strictError.Errors())
133 case isStrictError && validationDirective == metav1.FieldValidationIgnore:
134 klog.Warningf("unexpected strict error when field validation is set to ignore")
135 fallthrough
136 default:
137 err = transformDecodeError(scope.Typer, err, original, gvk, body)
138 scope.err(err, w, req)
139 return
140 }
141 }
142
143 objGV := gvk.GroupVersion()
144 if !scope.AcceptsGroupVersion(objGV) {
145 err = errors.NewBadRequest(fmt.Sprintf("the API version in the data (%s) does not match the expected API version (%v)", objGV.String(), gv.String()))
146 scope.err(err, w, req)
147 return
148 }
149 span.AddEvent("Conversion done")
150
151 // On create, get name from new object if unset
152 if len(name) == 0 {
153 _, name, _ = scope.Namer.ObjectName(obj)
154 }
155 if len(namespace) == 0 && scope.Resource == namespaceGVR {
156 namespace = name
157 }
158 ctx = request.WithNamespace(ctx, namespace)
159
160 admit = admission.WithAudit(admit)
161 audit.LogRequestObject(req.Context(), obj, objGV, scope.Resource, scope.Subresource, scope.Serializer)
162
163 userInfo, _ := request.UserFrom(ctx)
164
165 if objectMeta, err := meta.Accessor(obj); err == nil {
166 preserveObjectMetaSystemFields := false
167 if c, ok := r.(rest.SubresourceObjectMetaPreserver); ok && len(scope.Subresource) > 0 {
168 preserveObjectMetaSystemFields = c.PreserveRequestObjectMetaSystemFieldsOnSubresourceCreate()
169 }
170 if !preserveObjectMetaSystemFields {
171 rest.WipeObjectMetaSystemFields(objectMeta)
172 }
173
174 // ensure namespace on the object is correct, or error if a conflicting namespace was set in the object
175 if err := rest.EnsureObjectNamespaceMatchesRequestNamespace(rest.ExpectedNamespaceForResource(namespace, scope.Resource), objectMeta); err != nil {
176 scope.err(err, w, req)
177 return
178 }
179 }
180
181 span.AddEvent("About to store object in database")
182 admissionAttributes := admission.NewAttributesRecord(obj, nil, scope.Kind, namespace, name, scope.Resource, scope.Subresource, admission.Create, options, dryrun.IsDryRun(options.DryRun), userInfo)
183 requestFunc := func() (runtime.Object, error) {
184 return r.Create(
185 ctx,
186 name,
187 obj,
188 rest.AdmissionToValidateObjectFunc(admit, admissionAttributes, scope),
189 options,
190 )
191 }
192 // Dedup owner references before updating managed fields
193 dedupOwnerReferencesAndAddWarning(obj, req.Context(), false)
194 result, err := finisher.FinishRequest(ctx, func() (runtime.Object, error) {
195 liveObj, err := scope.Creater.New(scope.Kind)
196 if err != nil {
197 return nil, fmt.Errorf("failed to create new object (Create for %v): %v", scope.Kind, err)
198 }
199 obj = scope.FieldManager.UpdateNoErrors(liveObj, obj, managerOrUserAgent(options.FieldManager, req.UserAgent()))
200 admit = fieldmanager.NewManagedFieldsValidatingAdmissionController(admit)
201
202 if mutatingAdmission, ok := admit.(admission.MutationInterface); ok && mutatingAdmission.Handles(admission.Create) {
203 if err := mutatingAdmission.Admit(ctx, admissionAttributes, scope); err != nil {
204 return nil, err
205 }
206 }
207 // Dedup owner references again after mutating admission happens
208 dedupOwnerReferencesAndAddWarning(obj, req.Context(), true)
209 result, err := requestFunc()
210 // If the object wasn't committed to storage because it's serialized size was too large,
211 // it is safe to remove managedFields (which can be large) and try again.
212 if isTooLargeError(err) {
213 if accessor, accessorErr := meta.Accessor(obj); accessorErr == nil {
214 accessor.SetManagedFields(nil)
215 result, err = requestFunc()
216 }
217 }
218 return result, err
219 })
220 if err != nil {
221 span.AddEvent("Write to database call failed", attribute.Int("len", len(body)), attribute.String("err", err.Error()))
222 scope.err(err, w, req)
223 return
224 }
225 span.AddEvent("Write to database call succeeded", attribute.Int("len", len(body)))
226
227 code := http.StatusCreated
228 status, ok := result.(*metav1.Status)
229 if ok && status.Code == 0 {
230 status.Code = int32(code)
231 }
232
233 span.AddEvent("About to write a response")
234 defer span.AddEvent("Writing http response done")
235 transformResponseObject(ctx, scope, req, w, code, outputMediaType, result)
236 }
237 }
238
239 // CreateNamedResource returns a function that will handle a resource creation with name.
240 func CreateNamedResource(r rest.NamedCreater, scope *RequestScope, admission admission.Interface) http.HandlerFunc {
241 return createHandler(r, scope, admission, true)
242 }
243
244 // CreateResource returns a function that will handle a resource creation.
245 func CreateResource(r rest.Creater, scope *RequestScope, admission admission.Interface) http.HandlerFunc {
246 return createHandler(&namedCreaterAdapter{r}, scope, admission, false)
247 }
248
249 type namedCreaterAdapter struct {
250 rest.Creater
251 }
252
253 func (c *namedCreaterAdapter) Create(ctx context.Context, name string, obj runtime.Object, createValidatingAdmission rest.ValidateObjectFunc, options *metav1.CreateOptions) (runtime.Object, error) {
254 return c.Creater.Create(ctx, obj, createValidatingAdmission, options)
255 }
256
257 // manager is assumed to be already a valid value, we need to make
258 // userAgent into a valid value too.
259 func managerOrUserAgent(manager, userAgent string) string {
260 if manager != "" {
261 return manager
262 }
263 return prefixFromUserAgent(userAgent)
264 }
265
266 // prefixFromUserAgent takes the characters preceding the first /, quote
267 // unprintable character and then trim what's beyond the
268 // FieldManagerMaxLength limit.
269 func prefixFromUserAgent(u string) string {
270 m := strings.Split(u, "/")[0]
271 buf := bytes.NewBuffer(nil)
272 for _, r := range m {
273 // Ignore non-printable characters
274 if !unicode.IsPrint(r) {
275 continue
276 }
277 // Only append if we have room for it
278 if buf.Len()+utf8.RuneLen(r) > validation.FieldManagerMaxLength {
279 break
280 }
281 buf.WriteRune(r)
282 }
283 return buf.String()
284 }