mirror of https://github.com/k3s-io/k3s
258 lines
9.0 KiB
Go
258 lines
9.0 KiB
Go
/*
|
|
Copyright 2017 The Kubernetes Authors.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package handlers
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net/http"
|
|
|
|
"k8s.io/apimachinery/pkg/api/errors"
|
|
"k8s.io/apimachinery/pkg/api/meta"
|
|
metainternalversion "k8s.io/apimachinery/pkg/apis/meta/internalversion"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
metav1beta1 "k8s.io/apimachinery/pkg/apis/meta/v1beta1"
|
|
"k8s.io/apimachinery/pkg/apis/meta/v1beta1/validation"
|
|
"k8s.io/apimachinery/pkg/runtime"
|
|
"k8s.io/apimachinery/pkg/runtime/schema"
|
|
"k8s.io/apiserver/pkg/endpoints/handlers/negotiation"
|
|
"k8s.io/apiserver/pkg/endpoints/handlers/responsewriters"
|
|
utiltrace "k8s.io/utils/trace"
|
|
)
|
|
|
|
// transformObject takes the object as returned by storage and ensures it is in
|
|
// the client's desired form, as well as ensuring any API level fields like self-link
|
|
// are properly set.
|
|
func transformObject(ctx context.Context, obj runtime.Object, opts interface{}, mediaType negotiation.MediaTypeOptions, scope *RequestScope, req *http.Request) (runtime.Object, error) {
|
|
if _, ok := obj.(*metav1.Status); ok {
|
|
return obj, nil
|
|
}
|
|
if err := setObjectSelfLink(ctx, obj, req, scope.Namer); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
switch target := mediaType.Convert; {
|
|
case target == nil:
|
|
return obj, nil
|
|
|
|
case target.Kind == "PartialObjectMetadata":
|
|
return asPartialObjectMetadata(obj, target.GroupVersion())
|
|
|
|
case target.Kind == "PartialObjectMetadataList":
|
|
return asPartialObjectMetadataList(obj, target.GroupVersion())
|
|
|
|
case target.Kind == "Table":
|
|
options, ok := opts.(*metav1beta1.TableOptions)
|
|
if !ok {
|
|
return nil, fmt.Errorf("unexpected TableOptions, got %T", opts)
|
|
}
|
|
return asTable(ctx, obj, options, scope, target.GroupVersion())
|
|
|
|
default:
|
|
accepted, _ := negotiation.MediaTypesForSerializer(metainternalversion.Codecs)
|
|
err := negotiation.NewNotAcceptableError(accepted)
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
// optionsForTransform will load and validate any additional query parameter options for
|
|
// a conversion or return an error.
|
|
func optionsForTransform(mediaType negotiation.MediaTypeOptions, req *http.Request) (interface{}, error) {
|
|
switch target := mediaType.Convert; {
|
|
case target == nil:
|
|
case target.Kind == "Table" && (target.GroupVersion() == metav1beta1.SchemeGroupVersion || target.GroupVersion() == metav1.SchemeGroupVersion):
|
|
opts := &metav1beta1.TableOptions{}
|
|
if err := metav1beta1.ParameterCodec.DecodeParameters(req.URL.Query(), metav1beta1.SchemeGroupVersion, opts); err != nil {
|
|
return nil, err
|
|
}
|
|
switch errs := validation.ValidateTableOptions(opts); len(errs) {
|
|
case 0:
|
|
return opts, nil
|
|
case 1:
|
|
return nil, errors.NewBadRequest(fmt.Sprintf("Unable to convert to Table as requested: %v", errs[0].Error()))
|
|
default:
|
|
return nil, errors.NewBadRequest(fmt.Sprintf("Unable to convert to Table as requested: %v", errs))
|
|
}
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
// targetEncodingForTransform returns the appropriate serializer for the input media type
|
|
func targetEncodingForTransform(scope *RequestScope, mediaType negotiation.MediaTypeOptions, req *http.Request) (schema.GroupVersionKind, runtime.NegotiatedSerializer, bool) {
|
|
switch target := mediaType.Convert; {
|
|
case target == nil:
|
|
case (target.Kind == "PartialObjectMetadata" || target.Kind == "PartialObjectMetadataList" || target.Kind == "Table") &&
|
|
(target.GroupVersion() == metav1beta1.SchemeGroupVersion || target.GroupVersion() == metav1.SchemeGroupVersion):
|
|
return *target, metainternalversion.Codecs, true
|
|
}
|
|
return scope.Kind, scope.Serializer, false
|
|
}
|
|
|
|
// transformResponseObject takes an object loaded from storage and performs any necessary transformations.
|
|
// Will write the complete response object.
|
|
func transformResponseObject(ctx context.Context, scope *RequestScope, trace *utiltrace.Trace, req *http.Request, w http.ResponseWriter, statusCode int, mediaType negotiation.MediaTypeOptions, result runtime.Object) {
|
|
options, err := optionsForTransform(mediaType, req)
|
|
if err != nil {
|
|
scope.err(err, w, req)
|
|
return
|
|
}
|
|
obj, err := transformObject(ctx, result, options, mediaType, scope, req)
|
|
if err != nil {
|
|
scope.err(err, w, req)
|
|
return
|
|
}
|
|
kind, serializer, _ := targetEncodingForTransform(scope, mediaType, req)
|
|
responsewriters.WriteObjectNegotiated(serializer, scope, kind.GroupVersion(), w, req, statusCode, obj)
|
|
}
|
|
|
|
// errNotAcceptable indicates Accept negotiation has failed
|
|
type errNotAcceptable struct {
|
|
message string
|
|
}
|
|
|
|
func newNotAcceptableError(message string) error {
|
|
return errNotAcceptable{message}
|
|
}
|
|
|
|
func (e errNotAcceptable) Error() string {
|
|
return e.message
|
|
}
|
|
|
|
func (e errNotAcceptable) Status() metav1.Status {
|
|
return metav1.Status{
|
|
Status: metav1.StatusFailure,
|
|
Code: http.StatusNotAcceptable,
|
|
Reason: metav1.StatusReason("NotAcceptable"),
|
|
Message: e.Error(),
|
|
}
|
|
}
|
|
|
|
func asTable(ctx context.Context, result runtime.Object, opts *metav1beta1.TableOptions, scope *RequestScope, groupVersion schema.GroupVersion) (runtime.Object, error) {
|
|
switch groupVersion {
|
|
case metav1beta1.SchemeGroupVersion, metav1.SchemeGroupVersion:
|
|
default:
|
|
return nil, newNotAcceptableError(fmt.Sprintf("no Table exists in group version %s", groupVersion))
|
|
}
|
|
|
|
obj, err := scope.TableConvertor.ConvertToTable(ctx, result, opts)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
table := (*metav1.Table)(obj)
|
|
|
|
for i := range table.Rows {
|
|
item := &table.Rows[i]
|
|
switch opts.IncludeObject {
|
|
case metav1.IncludeObject:
|
|
item.Object.Object, err = scope.Convertor.ConvertToVersion(item.Object.Object, scope.Kind.GroupVersion())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// TODO: rely on defaulting for the value here?
|
|
case metav1.IncludeMetadata, "":
|
|
m, err := meta.Accessor(item.Object.Object)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// TODO: turn this into an internal type and do conversion in order to get object kind automatically set?
|
|
partial := meta.AsPartialObjectMetadata(m)
|
|
partial.GetObjectKind().SetGroupVersionKind(groupVersion.WithKind("PartialObjectMetadata"))
|
|
item.Object.Object = partial
|
|
case metav1.IncludeNone:
|
|
item.Object.Object = nil
|
|
default:
|
|
err = errors.NewBadRequest(fmt.Sprintf("unrecognized includeObject value: %q", opts.IncludeObject))
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
return table, nil
|
|
}
|
|
|
|
func asPartialObjectMetadata(result runtime.Object, groupVersion schema.GroupVersion) (runtime.Object, error) {
|
|
if meta.IsListType(result) {
|
|
err := newNotAcceptableError(fmt.Sprintf("you requested PartialObjectMetadata, but the requested object is a list (%T)", result))
|
|
return nil, err
|
|
}
|
|
switch groupVersion {
|
|
case metav1beta1.SchemeGroupVersion, metav1.SchemeGroupVersion:
|
|
default:
|
|
return nil, newNotAcceptableError(fmt.Sprintf("no PartialObjectMetadataList exists in group version %s", groupVersion))
|
|
}
|
|
m, err := meta.Accessor(result)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
partial := meta.AsPartialObjectMetadata(m)
|
|
partial.GetObjectKind().SetGroupVersionKind(groupVersion.WithKind("PartialObjectMetadata"))
|
|
return partial, nil
|
|
}
|
|
|
|
func asPartialObjectMetadataList(result runtime.Object, groupVersion schema.GroupVersion) (runtime.Object, error) {
|
|
li, ok := result.(metav1.ListInterface)
|
|
if !ok {
|
|
return nil, newNotAcceptableError(fmt.Sprintf("you requested PartialObjectMetadataList, but the requested object is not a list (%T)", result))
|
|
}
|
|
|
|
gvk := groupVersion.WithKind("PartialObjectMetadata")
|
|
switch {
|
|
case groupVersion == metav1beta1.SchemeGroupVersion:
|
|
list := &metav1beta1.PartialObjectMetadataList{}
|
|
err := meta.EachListItem(result, func(obj runtime.Object) error {
|
|
m, err := meta.Accessor(obj)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
partial := meta.AsPartialObjectMetadata(m)
|
|
partial.GetObjectKind().SetGroupVersionKind(gvk)
|
|
list.Items = append(list.Items, *partial)
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
list.SelfLink = li.GetSelfLink()
|
|
list.ResourceVersion = li.GetResourceVersion()
|
|
list.Continue = li.GetContinue()
|
|
return list, nil
|
|
|
|
case groupVersion == metav1.SchemeGroupVersion:
|
|
list := &metav1.PartialObjectMetadataList{}
|
|
err := meta.EachListItem(result, func(obj runtime.Object) error {
|
|
m, err := meta.Accessor(obj)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
partial := meta.AsPartialObjectMetadata(m)
|
|
partial.GetObjectKind().SetGroupVersionKind(gvk)
|
|
list.Items = append(list.Items, *partial)
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
list.SelfLink = li.GetSelfLink()
|
|
list.ResourceVersion = li.GetResourceVersion()
|
|
list.Continue = li.GetContinue()
|
|
return list, nil
|
|
|
|
default:
|
|
return nil, newNotAcceptableError(fmt.Sprintf("no PartialObjectMetadataList exists in group version %s", groupVersion))
|
|
}
|
|
}
|