diff options
Diffstat (limited to 'vendor/k8s.io/apimachinery/pkg/runtime')
25 files changed, 0 insertions, 5336 deletions
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/codec.go b/vendor/k8s.io/apimachinery/pkg/runtime/codec.go deleted file mode 100644 index a92863139..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/codec.go +++ /dev/null @@ -1,396 +0,0 @@ -/* -Copyright 2014 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 runtime - -import ( - "bytes" - "encoding/base64" - "encoding/json" - "fmt" - "io" - "net/url" - "reflect" - "strconv" - "strings" - - "k8s.io/apimachinery/pkg/conversion/queryparams" - "k8s.io/apimachinery/pkg/runtime/schema" - "k8s.io/klog/v2" -) - -// codec binds an encoder and decoder. -type codec struct { - Encoder - Decoder -} - -// NewCodec creates a Codec from an Encoder and Decoder. -func NewCodec(e Encoder, d Decoder) Codec { - return codec{e, d} -} - -// Encode is a convenience wrapper for encoding to a []byte from an Encoder -func Encode(e Encoder, obj Object) ([]byte, error) { - // TODO: reuse buffer - buf := &bytes.Buffer{} - if err := e.Encode(obj, buf); err != nil { - return nil, err - } - return buf.Bytes(), nil -} - -// Decode is a convenience wrapper for decoding data into an Object. -func Decode(d Decoder, data []byte) (Object, error) { - obj, _, err := d.Decode(data, nil, nil) - return obj, err -} - -// DecodeInto performs a Decode into the provided object. -func DecodeInto(d Decoder, data []byte, into Object) error { - out, gvk, err := d.Decode(data, nil, into) - if err != nil { - return err - } - if out != into { - return fmt.Errorf("unable to decode %s into %v", gvk, reflect.TypeOf(into)) - } - return nil -} - -// EncodeOrDie is a version of Encode which will panic instead of returning an error. For tests. -func EncodeOrDie(e Encoder, obj Object) string { - bytes, err := Encode(e, obj) - if err != nil { - panic(err) - } - return string(bytes) -} - -// UseOrCreateObject returns obj if the canonical ObjectKind returned by the provided typer matches gvk, or -// invokes the ObjectCreator to instantiate a new gvk. Returns an error if the typer cannot find the object. -func UseOrCreateObject(t ObjectTyper, c ObjectCreater, gvk schema.GroupVersionKind, obj Object) (Object, error) { - if obj != nil { - kinds, _, err := t.ObjectKinds(obj) - if err != nil { - return nil, err - } - for _, kind := range kinds { - if gvk == kind { - return obj, nil - } - } - } - return c.New(gvk) -} - -// NoopEncoder converts an Decoder to a Serializer or Codec for code that expects them but only uses decoding. -type NoopEncoder struct { - Decoder -} - -var _ Serializer = NoopEncoder{} - -const noopEncoderIdentifier Identifier = "noop" - -func (n NoopEncoder) Encode(obj Object, w io.Writer) error { - // There is no need to handle runtime.CacheableObject, as we don't - // process the obj at all. - return fmt.Errorf("encoding is not allowed for this codec: %v", reflect.TypeOf(n.Decoder)) -} - -// Identifier implements runtime.Encoder interface. -func (n NoopEncoder) Identifier() Identifier { - return noopEncoderIdentifier -} - -// NoopDecoder converts an Encoder to a Serializer or Codec for code that expects them but only uses encoding. -type NoopDecoder struct { - Encoder -} - -var _ Serializer = NoopDecoder{} - -func (n NoopDecoder) Decode(data []byte, gvk *schema.GroupVersionKind, into Object) (Object, *schema.GroupVersionKind, error) { - return nil, nil, fmt.Errorf("decoding is not allowed for this codec: %v", reflect.TypeOf(n.Encoder)) -} - -// NewParameterCodec creates a ParameterCodec capable of transforming url values into versioned objects and back. -func NewParameterCodec(scheme *Scheme) ParameterCodec { - return ¶meterCodec{ - typer: scheme, - convertor: scheme, - creator: scheme, - defaulter: scheme, - } -} - -// parameterCodec implements conversion to and from query parameters and objects. -type parameterCodec struct { - typer ObjectTyper - convertor ObjectConvertor - creator ObjectCreater - defaulter ObjectDefaulter -} - -var _ ParameterCodec = ¶meterCodec{} - -// DecodeParameters converts the provided url.Values into an object of type From with the kind of into, and then -// converts that object to into (if necessary). Returns an error if the operation cannot be completed. -func (c *parameterCodec) DecodeParameters(parameters url.Values, from schema.GroupVersion, into Object) error { - if len(parameters) == 0 { - return nil - } - targetGVKs, _, err := c.typer.ObjectKinds(into) - if err != nil { - return err - } - for i := range targetGVKs { - if targetGVKs[i].GroupVersion() == from { - if err := c.convertor.Convert(¶meters, into, nil); err != nil { - return err - } - // in the case where we going into the same object we're receiving, default on the outbound object - if c.defaulter != nil { - c.defaulter.Default(into) - } - return nil - } - } - - input, err := c.creator.New(from.WithKind(targetGVKs[0].Kind)) - if err != nil { - return err - } - if err := c.convertor.Convert(¶meters, input, nil); err != nil { - return err - } - // if we have defaulter, default the input before converting to output - if c.defaulter != nil { - c.defaulter.Default(input) - } - return c.convertor.Convert(input, into, nil) -} - -// EncodeParameters converts the provided object into the to version, then converts that object to url.Values. -// Returns an error if conversion is not possible. -func (c *parameterCodec) EncodeParameters(obj Object, to schema.GroupVersion) (url.Values, error) { - gvks, _, err := c.typer.ObjectKinds(obj) - if err != nil { - return nil, err - } - gvk := gvks[0] - if to != gvk.GroupVersion() { - out, err := c.convertor.ConvertToVersion(obj, to) - if err != nil { - return nil, err - } - obj = out - } - return queryparams.Convert(obj) -} - -type base64Serializer struct { - Encoder - Decoder - - identifier Identifier -} - -func NewBase64Serializer(e Encoder, d Decoder) Serializer { - return &base64Serializer{ - Encoder: e, - Decoder: d, - identifier: identifier(e), - } -} - -func identifier(e Encoder) Identifier { - result := map[string]string{ - "name": "base64", - } - if e != nil { - result["encoder"] = string(e.Identifier()) - } - identifier, err := json.Marshal(result) - if err != nil { - klog.Fatalf("Failed marshaling identifier for base64Serializer: %v", err) - } - return Identifier(identifier) -} - -func (s base64Serializer) Encode(obj Object, stream io.Writer) error { - if co, ok := obj.(CacheableObject); ok { - return co.CacheEncode(s.Identifier(), s.doEncode, stream) - } - return s.doEncode(obj, stream) -} - -func (s base64Serializer) doEncode(obj Object, stream io.Writer) error { - e := base64.NewEncoder(base64.StdEncoding, stream) - err := s.Encoder.Encode(obj, e) - e.Close() - return err -} - -// Identifier implements runtime.Encoder interface. -func (s base64Serializer) Identifier() Identifier { - return s.identifier -} - -func (s base64Serializer) Decode(data []byte, defaults *schema.GroupVersionKind, into Object) (Object, *schema.GroupVersionKind, error) { - out := make([]byte, base64.StdEncoding.DecodedLen(len(data))) - n, err := base64.StdEncoding.Decode(out, data) - if err != nil { - return nil, nil, err - } - return s.Decoder.Decode(out[:n], defaults, into) -} - -// SerializerInfoForMediaType returns the first info in types that has a matching media type (which cannot -// include media-type parameters), or the first info with an empty media type, or false if no type matches. -func SerializerInfoForMediaType(types []SerializerInfo, mediaType string) (SerializerInfo, bool) { - for _, info := range types { - if info.MediaType == mediaType { - return info, true - } - } - for _, info := range types { - if len(info.MediaType) == 0 { - return info, true - } - } - return SerializerInfo{}, false -} - -var ( - // InternalGroupVersioner will always prefer the internal version for a given group version kind. - InternalGroupVersioner GroupVersioner = internalGroupVersioner{} - // DisabledGroupVersioner will reject all kinds passed to it. - DisabledGroupVersioner GroupVersioner = disabledGroupVersioner{} -) - -const ( - internalGroupVersionerIdentifier = "internal" - disabledGroupVersionerIdentifier = "disabled" -) - -type internalGroupVersioner struct{} - -// KindForGroupVersionKinds returns an internal Kind if one is found, or converts the first provided kind to the internal version. -func (internalGroupVersioner) KindForGroupVersionKinds(kinds []schema.GroupVersionKind) (schema.GroupVersionKind, bool) { - for _, kind := range kinds { - if kind.Version == APIVersionInternal { - return kind, true - } - } - for _, kind := range kinds { - return schema.GroupVersionKind{Group: kind.Group, Version: APIVersionInternal, Kind: kind.Kind}, true - } - return schema.GroupVersionKind{}, false -} - -// Identifier implements GroupVersioner interface. -func (internalGroupVersioner) Identifier() string { - return internalGroupVersionerIdentifier -} - -type disabledGroupVersioner struct{} - -// KindForGroupVersionKinds returns false for any input. -func (disabledGroupVersioner) KindForGroupVersionKinds(kinds []schema.GroupVersionKind) (schema.GroupVersionKind, bool) { - return schema.GroupVersionKind{}, false -} - -// Identifier implements GroupVersioner interface. -func (disabledGroupVersioner) Identifier() string { - return disabledGroupVersionerIdentifier -} - -// Assert that schema.GroupVersion and GroupVersions implement GroupVersioner -var _ GroupVersioner = schema.GroupVersion{} -var _ GroupVersioner = schema.GroupVersions{} -var _ GroupVersioner = multiGroupVersioner{} - -type multiGroupVersioner struct { - target schema.GroupVersion - acceptedGroupKinds []schema.GroupKind - coerce bool -} - -// NewMultiGroupVersioner returns the provided group version for any kind that matches one of the provided group kinds. -// Kind may be empty in the provided group kind, in which case any kind will match. -func NewMultiGroupVersioner(gv schema.GroupVersion, groupKinds ...schema.GroupKind) GroupVersioner { - if len(groupKinds) == 0 || (len(groupKinds) == 1 && groupKinds[0].Group == gv.Group) { - return gv - } - return multiGroupVersioner{target: gv, acceptedGroupKinds: groupKinds} -} - -// NewCoercingMultiGroupVersioner returns the provided group version for any incoming kind. -// Incoming kinds that match the provided groupKinds are preferred. -// Kind may be empty in the provided group kind, in which case any kind will match. -// Examples: -// gv=mygroup/__internal, groupKinds=mygroup/Foo, anothergroup/Bar -// KindForGroupVersionKinds(yetanother/v1/Baz, anothergroup/v1/Bar) -> mygroup/__internal/Bar (matched preferred group/kind) -// -// gv=mygroup/__internal, groupKinds=mygroup, anothergroup -// KindForGroupVersionKinds(yetanother/v1/Baz, anothergroup/v1/Bar) -> mygroup/__internal/Bar (matched preferred group) -// -// gv=mygroup/__internal, groupKinds=mygroup, anothergroup -// KindForGroupVersionKinds(yetanother/v1/Baz, yetanother/v1/Bar) -> mygroup/__internal/Baz (no preferred group/kind match, uses first kind in list) -func NewCoercingMultiGroupVersioner(gv schema.GroupVersion, groupKinds ...schema.GroupKind) GroupVersioner { - return multiGroupVersioner{target: gv, acceptedGroupKinds: groupKinds, coerce: true} -} - -// KindForGroupVersionKinds returns the target group version if any kind matches any of the original group kinds. It will -// use the originating kind where possible. -func (v multiGroupVersioner) KindForGroupVersionKinds(kinds []schema.GroupVersionKind) (schema.GroupVersionKind, bool) { - for _, src := range kinds { - for _, kind := range v.acceptedGroupKinds { - if kind.Group != src.Group { - continue - } - if len(kind.Kind) > 0 && kind.Kind != src.Kind { - continue - } - return v.target.WithKind(src.Kind), true - } - } - if v.coerce && len(kinds) > 0 { - return v.target.WithKind(kinds[0].Kind), true - } - return schema.GroupVersionKind{}, false -} - -// Identifier implements GroupVersioner interface. -func (v multiGroupVersioner) Identifier() string { - groupKinds := make([]string, 0, len(v.acceptedGroupKinds)) - for _, gk := range v.acceptedGroupKinds { - groupKinds = append(groupKinds, gk.String()) - } - result := map[string]string{ - "name": "multi", - "target": v.target.String(), - "accepted": strings.Join(groupKinds, ","), - "coerce": strconv.FormatBool(v.coerce), - } - identifier, err := json.Marshal(result) - if err != nil { - klog.Fatalf("Failed marshaling Identifier for %#v: %v", v, err) - } - return string(identifier) -} diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/codec_check.go b/vendor/k8s.io/apimachinery/pkg/runtime/codec_check.go deleted file mode 100644 index 000228061..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/codec_check.go +++ /dev/null @@ -1,56 +0,0 @@ -/* -Copyright 2016 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 runtime - -import ( - "fmt" - "reflect" - - "k8s.io/apimachinery/pkg/runtime/schema" - "k8s.io/apimachinery/pkg/util/json" -) - -// CheckCodec makes sure that the codec can encode objects like internalType, -// decode all of the external types listed, and also decode them into the given -// object. (Will modify internalObject.) (Assumes JSON serialization.) -// TODO: verify that the correct external version is chosen on encode... -func CheckCodec(c Codec, internalType Object, externalTypes ...schema.GroupVersionKind) error { - if _, err := Encode(c, internalType); err != nil { - return fmt.Errorf("Internal type not encodable: %v", err) - } - for _, et := range externalTypes { - typeMeta := TypeMeta{ - Kind: et.Kind, - APIVersion: et.GroupVersion().String(), - } - exBytes, err := json.Marshal(&typeMeta) - if err != nil { - return err - } - obj, err := Decode(c, exBytes) - if err != nil { - return fmt.Errorf("external type %s not interpretable: %v", et, err) - } - if reflect.TypeOf(obj) != reflect.TypeOf(internalType) { - return fmt.Errorf("decode of external type %s produced: %#v", et, obj) - } - if err = DecodeInto(c, exBytes, internalType); err != nil { - return fmt.Errorf("external type %s not convertible to internal type: %v", et, err) - } - } - return nil -} diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/conversion.go b/vendor/k8s.io/apimachinery/pkg/runtime/conversion.go deleted file mode 100644 index d04d701f3..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/conversion.go +++ /dev/null @@ -1,196 +0,0 @@ -/* -Copyright 2014 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 runtime defines conversions between generic types and structs to map query strings -// to struct objects. -package runtime - -import ( - "fmt" - "reflect" - "strconv" - "strings" - - "k8s.io/apimachinery/pkg/conversion" -) - -// DefaultMetaV1FieldSelectorConversion auto-accepts metav1 values for name and namespace. -// A cluster scoped resource specifying namespace empty works fine and specifying a particular -// namespace will return no results, as expected. -func DefaultMetaV1FieldSelectorConversion(label, value string) (string, string, error) { - switch label { - case "metadata.name": - return label, value, nil - case "metadata.namespace": - return label, value, nil - default: - return "", "", fmt.Errorf("%q is not a known field selector: only %q, %q", label, "metadata.name", "metadata.namespace") - } -} - -// JSONKeyMapper uses the struct tags on a conversion to determine the key value for -// the other side. Use when mapping from a map[string]* to a struct or vice versa. -func JSONKeyMapper(key string, sourceTag, destTag reflect.StructTag) (string, string) { - if s := destTag.Get("json"); len(s) > 0 { - return strings.SplitN(s, ",", 2)[0], key - } - if s := sourceTag.Get("json"); len(s) > 0 { - return key, strings.SplitN(s, ",", 2)[0] - } - return key, key -} - -func Convert_Slice_string_To_string(in *[]string, out *string, s conversion.Scope) error { - if len(*in) == 0 { - *out = "" - return nil - } - *out = (*in)[0] - return nil -} - -func Convert_Slice_string_To_int(in *[]string, out *int, s conversion.Scope) error { - if len(*in) == 0 { - *out = 0 - return nil - } - str := (*in)[0] - i, err := strconv.Atoi(str) - if err != nil { - return err - } - *out = i - return nil -} - -// Convert_Slice_string_To_bool will convert a string parameter to boolean. -// Only the absence of a value (i.e. zero-length slice), a value of "false", or a -// value of "0" resolve to false. -// Any other value (including empty string) resolves to true. -func Convert_Slice_string_To_bool(in *[]string, out *bool, s conversion.Scope) error { - if len(*in) == 0 { - *out = false - return nil - } - switch { - case (*in)[0] == "0", strings.EqualFold((*in)[0], "false"): - *out = false - default: - *out = true - } - return nil -} - -// Convert_Slice_string_To_bool will convert a string parameter to boolean. -// Only the absence of a value (i.e. zero-length slice), a value of "false", or a -// value of "0" resolve to false. -// Any other value (including empty string) resolves to true. -func Convert_Slice_string_To_Pointer_bool(in *[]string, out **bool, s conversion.Scope) error { - if len(*in) == 0 { - boolVar := false - *out = &boolVar - return nil - } - switch { - case (*in)[0] == "0", strings.EqualFold((*in)[0], "false"): - boolVar := false - *out = &boolVar - default: - boolVar := true - *out = &boolVar - } - return nil -} - -func string_to_int64(in string) (int64, error) { - return strconv.ParseInt(in, 10, 64) -} - -func Convert_string_To_int64(in *string, out *int64, s conversion.Scope) error { - if in == nil { - *out = 0 - return nil - } - i, err := string_to_int64(*in) - if err != nil { - return err - } - *out = i - return nil -} - -func Convert_Slice_string_To_int64(in *[]string, out *int64, s conversion.Scope) error { - if len(*in) == 0 { - *out = 0 - return nil - } - i, err := string_to_int64((*in)[0]) - if err != nil { - return err - } - *out = i - return nil -} - -func Convert_string_To_Pointer_int64(in *string, out **int64, s conversion.Scope) error { - if in == nil { - *out = nil - return nil - } - i, err := string_to_int64(*in) - if err != nil { - return err - } - *out = &i - return nil -} - -func Convert_Slice_string_To_Pointer_int64(in *[]string, out **int64, s conversion.Scope) error { - if len(*in) == 0 { - *out = nil - return nil - } - i, err := string_to_int64((*in)[0]) - if err != nil { - return err - } - *out = &i - return nil -} - -func RegisterStringConversions(s *Scheme) error { - if err := s.AddConversionFunc((*[]string)(nil), (*string)(nil), func(a, b interface{}, scope conversion.Scope) error { - return Convert_Slice_string_To_string(a.(*[]string), b.(*string), scope) - }); err != nil { - return err - } - if err := s.AddConversionFunc((*[]string)(nil), (*int)(nil), func(a, b interface{}, scope conversion.Scope) error { - return Convert_Slice_string_To_int(a.(*[]string), b.(*int), scope) - }); err != nil { - return err - } - if err := s.AddConversionFunc((*[]string)(nil), (*bool)(nil), func(a, b interface{}, scope conversion.Scope) error { - return Convert_Slice_string_To_bool(a.(*[]string), b.(*bool), scope) - }); err != nil { - return err - } - if err := s.AddConversionFunc((*[]string)(nil), (*int64)(nil), func(a, b interface{}, scope conversion.Scope) error { - return Convert_Slice_string_To_int64(a.(*[]string), b.(*int64), scope) - }); err != nil { - return err - } - return nil -} diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/converter.go b/vendor/k8s.io/apimachinery/pkg/runtime/converter.go deleted file mode 100644 index 4a6cc6857..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/converter.go +++ /dev/null @@ -1,710 +0,0 @@ -/* -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 runtime - -import ( - encodingjson "encoding/json" - "fmt" - "math" - "os" - "reflect" - "strconv" - "strings" - "sync" - "sync/atomic" - "time" - - "k8s.io/apimachinery/pkg/conversion" - "k8s.io/apimachinery/pkg/util/json" - utilruntime "k8s.io/apimachinery/pkg/util/runtime" - "sigs.k8s.io/structured-merge-diff/v4/value" - - "k8s.io/klog/v2" -) - -// UnstructuredConverter is an interface for converting between interface{} -// and map[string]interface representation. -type UnstructuredConverter interface { - ToUnstructured(obj interface{}) (map[string]interface{}, error) - FromUnstructured(u map[string]interface{}, obj interface{}) error -} - -type structField struct { - structType reflect.Type - field int -} - -type fieldInfo struct { - name string - nameValue reflect.Value - omitempty bool -} - -type fieldsCacheMap map[structField]*fieldInfo - -type fieldsCache struct { - sync.Mutex - value atomic.Value -} - -func newFieldsCache() *fieldsCache { - cache := &fieldsCache{} - cache.value.Store(make(fieldsCacheMap)) - return cache -} - -var ( - mapStringInterfaceType = reflect.TypeOf(map[string]interface{}{}) - stringType = reflect.TypeOf(string("")) - fieldCache = newFieldsCache() - - // DefaultUnstructuredConverter performs unstructured to Go typed object conversions. - DefaultUnstructuredConverter = &unstructuredConverter{ - mismatchDetection: parseBool(os.Getenv("KUBE_PATCH_CONVERSION_DETECTOR")), - comparison: conversion.EqualitiesOrDie( - func(a, b time.Time) bool { - return a.UTC() == b.UTC() - }, - ), - } -) - -func parseBool(key string) bool { - if len(key) == 0 { - return false - } - value, err := strconv.ParseBool(key) - if err != nil { - utilruntime.HandleError(fmt.Errorf("couldn't parse '%s' as bool for unstructured mismatch detection", key)) - } - return value -} - -// unstructuredConverter knows how to convert between interface{} and -// Unstructured in both ways. -type unstructuredConverter struct { - // If true, we will be additionally running conversion via json - // to ensure that the result is true. - // This is supposed to be set only in tests. - mismatchDetection bool - // comparison is the default test logic used to compare - comparison conversion.Equalities -} - -// NewTestUnstructuredConverter creates an UnstructuredConverter that accepts JSON typed maps and translates them -// to Go types via reflection. It performs mismatch detection automatically and is intended for use by external -// test tools. Use DefaultUnstructuredConverter if you do not explicitly need mismatch detection. -func NewTestUnstructuredConverter(comparison conversion.Equalities) UnstructuredConverter { - return &unstructuredConverter{ - mismatchDetection: true, - comparison: comparison, - } -} - -// FromUnstructured converts an object from map[string]interface{} representation into a concrete type. -// It uses encoding/json/Unmarshaler if object implements it or reflection if not. -func (c *unstructuredConverter) FromUnstructured(u map[string]interface{}, obj interface{}) error { - t := reflect.TypeOf(obj) - value := reflect.ValueOf(obj) - if t.Kind() != reflect.Ptr || value.IsNil() { - return fmt.Errorf("FromUnstructured requires a non-nil pointer to an object, got %v", t) - } - err := fromUnstructured(reflect.ValueOf(u), value.Elem()) - if c.mismatchDetection { - newObj := reflect.New(t.Elem()).Interface() - newErr := fromUnstructuredViaJSON(u, newObj) - if (err != nil) != (newErr != nil) { - klog.Fatalf("FromUnstructured unexpected error for %v: error: %v", u, err) - } - if err == nil && !c.comparison.DeepEqual(obj, newObj) { - klog.Fatalf("FromUnstructured mismatch\nobj1: %#v\nobj2: %#v", obj, newObj) - } - } - return err -} - -func fromUnstructuredViaJSON(u map[string]interface{}, obj interface{}) error { - data, err := json.Marshal(u) - if err != nil { - return err - } - return json.Unmarshal(data, obj) -} - -func fromUnstructured(sv, dv reflect.Value) error { - sv = unwrapInterface(sv) - if !sv.IsValid() { - dv.Set(reflect.Zero(dv.Type())) - return nil - } - st, dt := sv.Type(), dv.Type() - - switch dt.Kind() { - case reflect.Map, reflect.Slice, reflect.Ptr, reflect.Struct, reflect.Interface: - // Those require non-trivial conversion. - default: - // This should handle all simple types. - if st.AssignableTo(dt) { - dv.Set(sv) - return nil - } - // We cannot simply use "ConvertibleTo", as JSON doesn't support conversions - // between those four groups: bools, integers, floats and string. We need to - // do the same. - if st.ConvertibleTo(dt) { - switch st.Kind() { - case reflect.String: - switch dt.Kind() { - case reflect.String: - dv.Set(sv.Convert(dt)) - return nil - } - case reflect.Bool: - switch dt.Kind() { - case reflect.Bool: - dv.Set(sv.Convert(dt)) - return nil - } - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, - reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - switch dt.Kind() { - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, - reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - dv.Set(sv.Convert(dt)) - return nil - case reflect.Float32, reflect.Float64: - dv.Set(sv.Convert(dt)) - return nil - } - case reflect.Float32, reflect.Float64: - switch dt.Kind() { - case reflect.Float32, reflect.Float64: - dv.Set(sv.Convert(dt)) - return nil - } - if sv.Float() == math.Trunc(sv.Float()) { - dv.Set(sv.Convert(dt)) - return nil - } - } - return fmt.Errorf("cannot convert %s to %s", st.String(), dt.String()) - } - } - - // Check if the object has a custom JSON marshaller/unmarshaller. - entry := value.TypeReflectEntryOf(dv.Type()) - if entry.CanConvertFromUnstructured() { - return entry.FromUnstructured(sv, dv) - } - - switch dt.Kind() { - case reflect.Map: - return mapFromUnstructured(sv, dv) - case reflect.Slice: - return sliceFromUnstructured(sv, dv) - case reflect.Ptr: - return pointerFromUnstructured(sv, dv) - case reflect.Struct: - return structFromUnstructured(sv, dv) - case reflect.Interface: - return interfaceFromUnstructured(sv, dv) - default: - return fmt.Errorf("unrecognized type: %v", dt.Kind()) - } -} - -func fieldInfoFromField(structType reflect.Type, field int) *fieldInfo { - fieldCacheMap := fieldCache.value.Load().(fieldsCacheMap) - if info, ok := fieldCacheMap[structField{structType, field}]; ok { - return info - } - - // Cache miss - we need to compute the field name. - info := &fieldInfo{} - typeField := structType.Field(field) - jsonTag := typeField.Tag.Get("json") - if len(jsonTag) == 0 { - // Make the first character lowercase. - if typeField.Name == "" { - info.name = typeField.Name - } else { - info.name = strings.ToLower(typeField.Name[:1]) + typeField.Name[1:] - } - } else { - items := strings.Split(jsonTag, ",") - info.name = items[0] - for i := range items { - if items[i] == "omitempty" { - info.omitempty = true - break - } - } - } - info.nameValue = reflect.ValueOf(info.name) - - fieldCache.Lock() - defer fieldCache.Unlock() - fieldCacheMap = fieldCache.value.Load().(fieldsCacheMap) - newFieldCacheMap := make(fieldsCacheMap) - for k, v := range fieldCacheMap { - newFieldCacheMap[k] = v - } - newFieldCacheMap[structField{structType, field}] = info - fieldCache.value.Store(newFieldCacheMap) - return info -} - -func unwrapInterface(v reflect.Value) reflect.Value { - for v.Kind() == reflect.Interface { - v = v.Elem() - } - return v -} - -func mapFromUnstructured(sv, dv reflect.Value) error { - st, dt := sv.Type(), dv.Type() - if st.Kind() != reflect.Map { - return fmt.Errorf("cannot restore map from %v", st.Kind()) - } - - if !st.Key().AssignableTo(dt.Key()) && !st.Key().ConvertibleTo(dt.Key()) { - return fmt.Errorf("cannot copy map with non-assignable keys: %v %v", st.Key(), dt.Key()) - } - - if sv.IsNil() { - dv.Set(reflect.Zero(dt)) - return nil - } - dv.Set(reflect.MakeMap(dt)) - for _, key := range sv.MapKeys() { - value := reflect.New(dt.Elem()).Elem() - if val := unwrapInterface(sv.MapIndex(key)); val.IsValid() { - if err := fromUnstructured(val, value); err != nil { - return err - } - } else { - value.Set(reflect.Zero(dt.Elem())) - } - if st.Key().AssignableTo(dt.Key()) { - dv.SetMapIndex(key, value) - } else { - dv.SetMapIndex(key.Convert(dt.Key()), value) - } - } - return nil -} - -func sliceFromUnstructured(sv, dv reflect.Value) error { - st, dt := sv.Type(), dv.Type() - if st.Kind() == reflect.String && dt.Elem().Kind() == reflect.Uint8 { - // We store original []byte representation as string. - // This conversion is allowed, but we need to be careful about - // marshaling data appropriately. - if len(sv.Interface().(string)) > 0 { - marshalled, err := json.Marshal(sv.Interface()) - if err != nil { - return fmt.Errorf("error encoding %s to json: %v", st, err) - } - // TODO: Is this Unmarshal needed? - var data []byte - err = json.Unmarshal(marshalled, &data) - if err != nil { - return fmt.Errorf("error decoding from json: %v", err) - } - dv.SetBytes(data) - } else { - dv.Set(reflect.Zero(dt)) - } - return nil - } - if st.Kind() != reflect.Slice { - return fmt.Errorf("cannot restore slice from %v", st.Kind()) - } - - if sv.IsNil() { - dv.Set(reflect.Zero(dt)) - return nil - } - dv.Set(reflect.MakeSlice(dt, sv.Len(), sv.Cap())) - for i := 0; i < sv.Len(); i++ { - if err := fromUnstructured(sv.Index(i), dv.Index(i)); err != nil { - return err - } - } - return nil -} - -func pointerFromUnstructured(sv, dv reflect.Value) error { - st, dt := sv.Type(), dv.Type() - - if st.Kind() == reflect.Ptr && sv.IsNil() { - dv.Set(reflect.Zero(dt)) - return nil - } - dv.Set(reflect.New(dt.Elem())) - switch st.Kind() { - case reflect.Ptr, reflect.Interface: - return fromUnstructured(sv.Elem(), dv.Elem()) - default: - return fromUnstructured(sv, dv.Elem()) - } -} - -func structFromUnstructured(sv, dv reflect.Value) error { - st, dt := sv.Type(), dv.Type() - if st.Kind() != reflect.Map { - return fmt.Errorf("cannot restore struct from: %v", st.Kind()) - } - - for i := 0; i < dt.NumField(); i++ { - fieldInfo := fieldInfoFromField(dt, i) - fv := dv.Field(i) - - if len(fieldInfo.name) == 0 { - // This field is inlined. - if err := fromUnstructured(sv, fv); err != nil { - return err - } - } else { - value := unwrapInterface(sv.MapIndex(fieldInfo.nameValue)) - if value.IsValid() { - if err := fromUnstructured(value, fv); err != nil { - return err - } - } else { - fv.Set(reflect.Zero(fv.Type())) - } - } - } - return nil -} - -func interfaceFromUnstructured(sv, dv reflect.Value) error { - // TODO: Is this conversion safe? - dv.Set(sv) - return nil -} - -// ToUnstructured converts an object into map[string]interface{} representation. -// It uses encoding/json/Marshaler if object implements it or reflection if not. -func (c *unstructuredConverter) ToUnstructured(obj interface{}) (map[string]interface{}, error) { - var u map[string]interface{} - var err error - if unstr, ok := obj.(Unstructured); ok { - u = unstr.UnstructuredContent() - } else { - t := reflect.TypeOf(obj) - value := reflect.ValueOf(obj) - if t.Kind() != reflect.Ptr || value.IsNil() { - return nil, fmt.Errorf("ToUnstructured requires a non-nil pointer to an object, got %v", t) - } - u = map[string]interface{}{} - err = toUnstructured(value.Elem(), reflect.ValueOf(&u).Elem()) - } - if c.mismatchDetection { - newUnstr := map[string]interface{}{} - newErr := toUnstructuredViaJSON(obj, &newUnstr) - if (err != nil) != (newErr != nil) { - klog.Fatalf("ToUnstructured unexpected error for %v: error: %v; newErr: %v", obj, err, newErr) - } - if err == nil && !c.comparison.DeepEqual(u, newUnstr) { - klog.Fatalf("ToUnstructured mismatch\nobj1: %#v\nobj2: %#v", u, newUnstr) - } - } - if err != nil { - return nil, err - } - return u, nil -} - -// DeepCopyJSON deep copies the passed value, assuming it is a valid JSON representation i.e. only contains -// types produced by json.Unmarshal() and also int64. -// bool, int64, float64, string, []interface{}, map[string]interface{}, json.Number and nil -func DeepCopyJSON(x map[string]interface{}) map[string]interface{} { - return DeepCopyJSONValue(x).(map[string]interface{}) -} - -// DeepCopyJSONValue deep copies the passed value, assuming it is a valid JSON representation i.e. only contains -// types produced by json.Unmarshal() and also int64. -// bool, int64, float64, string, []interface{}, map[string]interface{}, json.Number and nil -func DeepCopyJSONValue(x interface{}) interface{} { - switch x := x.(type) { - case map[string]interface{}: - if x == nil { - // Typed nil - an interface{} that contains a type map[string]interface{} with a value of nil - return x - } - clone := make(map[string]interface{}, len(x)) - for k, v := range x { - clone[k] = DeepCopyJSONValue(v) - } - return clone - case []interface{}: - if x == nil { - // Typed nil - an interface{} that contains a type []interface{} with a value of nil - return x - } - clone := make([]interface{}, len(x)) - for i, v := range x { - clone[i] = DeepCopyJSONValue(v) - } - return clone - case string, int64, bool, float64, nil, encodingjson.Number: - return x - default: - panic(fmt.Errorf("cannot deep copy %T", x)) - } -} - -func toUnstructuredViaJSON(obj interface{}, u *map[string]interface{}) error { - data, err := json.Marshal(obj) - if err != nil { - return err - } - return json.Unmarshal(data, u) -} - -func toUnstructured(sv, dv reflect.Value) error { - // Check if the object has a custom string converter. - entry := value.TypeReflectEntryOf(sv.Type()) - if entry.CanConvertToUnstructured() { - v, err := entry.ToUnstructured(sv) - if err != nil { - return err - } - if v != nil { - dv.Set(reflect.ValueOf(v)) - } - return nil - } - st := sv.Type() - switch st.Kind() { - case reflect.String: - dv.Set(reflect.ValueOf(sv.String())) - return nil - case reflect.Bool: - dv.Set(reflect.ValueOf(sv.Bool())) - return nil - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - dv.Set(reflect.ValueOf(sv.Int())) - return nil - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - uVal := sv.Uint() - if uVal > math.MaxInt64 { - return fmt.Errorf("unsigned value %d does not fit into int64 (overflow)", uVal) - } - dv.Set(reflect.ValueOf(int64(uVal))) - return nil - case reflect.Float32, reflect.Float64: - dv.Set(reflect.ValueOf(sv.Float())) - return nil - case reflect.Map: - return mapToUnstructured(sv, dv) - case reflect.Slice: - return sliceToUnstructured(sv, dv) - case reflect.Ptr: - return pointerToUnstructured(sv, dv) - case reflect.Struct: - return structToUnstructured(sv, dv) - case reflect.Interface: - return interfaceToUnstructured(sv, dv) - default: - return fmt.Errorf("unrecognized type: %v", st.Kind()) - } -} - -func mapToUnstructured(sv, dv reflect.Value) error { - st, dt := sv.Type(), dv.Type() - if sv.IsNil() { - dv.Set(reflect.Zero(dt)) - return nil - } - if dt.Kind() == reflect.Interface && dv.NumMethod() == 0 { - if st.Key().Kind() == reflect.String { - switch st.Elem().Kind() { - // TODO It should be possible to reuse the slice for primitive types. - // However, it is panicing in the following form. - // case reflect.String, reflect.Bool, - // reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, - // reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - // sv.Set(sv) - // return nil - default: - // We need to do a proper conversion. - } - } - dv.Set(reflect.MakeMap(mapStringInterfaceType)) - dv = dv.Elem() - dt = dv.Type() - } - if dt.Kind() != reflect.Map { - return fmt.Errorf("cannot convert struct to: %v", dt.Kind()) - } - - if !st.Key().AssignableTo(dt.Key()) && !st.Key().ConvertibleTo(dt.Key()) { - return fmt.Errorf("cannot copy map with non-assignable keys: %v %v", st.Key(), dt.Key()) - } - - for _, key := range sv.MapKeys() { - value := reflect.New(dt.Elem()).Elem() - if err := toUnstructured(sv.MapIndex(key), value); err != nil { - return err - } - if st.Key().AssignableTo(dt.Key()) { - dv.SetMapIndex(key, value) - } else { - dv.SetMapIndex(key.Convert(dt.Key()), value) - } - } - return nil -} - -func sliceToUnstructured(sv, dv reflect.Value) error { - st, dt := sv.Type(), dv.Type() - if sv.IsNil() { - dv.Set(reflect.Zero(dt)) - return nil - } - if st.Elem().Kind() == reflect.Uint8 { - dv.Set(reflect.New(stringType)) - data, err := json.Marshal(sv.Bytes()) - if err != nil { - return err - } - var result string - if err = json.Unmarshal(data, &result); err != nil { - return err - } - dv.Set(reflect.ValueOf(result)) - return nil - } - if dt.Kind() == reflect.Interface && dv.NumMethod() == 0 { - switch st.Elem().Kind() { - // TODO It should be possible to reuse the slice for primitive types. - // However, it is panicing in the following form. - // case reflect.String, reflect.Bool, - // reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, - // reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - // sv.Set(sv) - // return nil - default: - // We need to do a proper conversion. - dv.Set(reflect.MakeSlice(reflect.SliceOf(dt), sv.Len(), sv.Cap())) - dv = dv.Elem() - dt = dv.Type() - } - } - if dt.Kind() != reflect.Slice { - return fmt.Errorf("cannot convert slice to: %v", dt.Kind()) - } - for i := 0; i < sv.Len(); i++ { - if err := toUnstructured(sv.Index(i), dv.Index(i)); err != nil { - return err - } - } - return nil -} - -func pointerToUnstructured(sv, dv reflect.Value) error { - if sv.IsNil() { - // We're done - we don't need to store anything. - return nil - } - return toUnstructured(sv.Elem(), dv) -} - -func isZero(v reflect.Value) bool { - switch v.Kind() { - case reflect.Array, reflect.String: - return v.Len() == 0 - case reflect.Bool: - return !v.Bool() - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - return v.Int() == 0 - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - return v.Uint() == 0 - case reflect.Float32, reflect.Float64: - return v.Float() == 0 - case reflect.Map, reflect.Slice: - // TODO: It seems that 0-len maps are ignored in it. - return v.IsNil() || v.Len() == 0 - case reflect.Ptr, reflect.Interface: - return v.IsNil() - } - return false -} - -func structToUnstructured(sv, dv reflect.Value) error { - st, dt := sv.Type(), dv.Type() - if dt.Kind() == reflect.Interface && dv.NumMethod() == 0 { - dv.Set(reflect.MakeMapWithSize(mapStringInterfaceType, st.NumField())) - dv = dv.Elem() - dt = dv.Type() - } - if dt.Kind() != reflect.Map { - return fmt.Errorf("cannot convert struct to: %v", dt.Kind()) - } - realMap := dv.Interface().(map[string]interface{}) - - for i := 0; i < st.NumField(); i++ { - fieldInfo := fieldInfoFromField(st, i) - fv := sv.Field(i) - - if fieldInfo.name == "-" { - // This field should be skipped. - continue - } - if fieldInfo.omitempty && isZero(fv) { - // omitempty fields should be ignored. - continue - } - if len(fieldInfo.name) == 0 { - // This field is inlined. - if err := toUnstructured(fv, dv); err != nil { - return err - } - continue - } - switch fv.Type().Kind() { - case reflect.String: - realMap[fieldInfo.name] = fv.String() - case reflect.Bool: - realMap[fieldInfo.name] = fv.Bool() - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - realMap[fieldInfo.name] = fv.Int() - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - realMap[fieldInfo.name] = fv.Uint() - case reflect.Float32, reflect.Float64: - realMap[fieldInfo.name] = fv.Float() - default: - subv := reflect.New(dt.Elem()).Elem() - if err := toUnstructured(fv, subv); err != nil { - return err - } - dv.SetMapIndex(fieldInfo.nameValue, subv) - } - } - return nil -} - -func interfaceToUnstructured(sv, dv reflect.Value) error { - if !sv.IsValid() || sv.IsNil() { - dv.Set(reflect.Zero(dv.Type())) - return nil - } - return toUnstructured(sv.Elem(), dv) -} diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/doc.go b/vendor/k8s.io/apimachinery/pkg/runtime/doc.go deleted file mode 100644 index 89feb4010..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/doc.go +++ /dev/null @@ -1,51 +0,0 @@ -/* -Copyright 2014 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 runtime includes helper functions for working with API objects -// that follow the kubernetes API object conventions, which are: -// -// 0. Your API objects have a common metadata struct member, TypeMeta. -// -// 1. Your code refers to an internal set of API objects. -// -// 2. In a separate package, you have an external set of API objects. -// -// 3. The external set is considered to be versioned, and no breaking -// changes are ever made to it (fields may be added but not changed -// or removed). -// -// 4. As your api evolves, you'll make an additional versioned package -// with every major change. -// -// 5. Versioned packages have conversion functions which convert to -// and from the internal version. -// -// 6. You'll continue to support older versions according to your -// deprecation policy, and you can easily provide a program/library -// to update old versions into new versions because of 5. -// -// 7. All of your serializations and deserializations are handled in a -// centralized place. -// -// Package runtime provides a conversion helper to make 5 easy, and the -// Encode/Decode/DecodeInto trio to accomplish 7. You can also register -// additional "codecs" which use a version of your choice. It's -// recommended that you register your types with runtime in your -// package's init function. -// -// As a bonus, a few common types useful from all api objects and versions -// are provided in types.go. -package runtime // import "k8s.io/apimachinery/pkg/runtime" diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/embedded.go b/vendor/k8s.io/apimachinery/pkg/runtime/embedded.go deleted file mode 100644 index 7251e65f6..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/embedded.go +++ /dev/null @@ -1,149 +0,0 @@ -/* -Copyright 2014 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 runtime - -import ( - "errors" - - "k8s.io/apimachinery/pkg/conversion" - "k8s.io/apimachinery/pkg/runtime/schema" -) - -type encodable struct { - E Encoder `json:"-"` - obj Object - versions []schema.GroupVersion -} - -func (e encodable) GetObjectKind() schema.ObjectKind { return e.obj.GetObjectKind() } -func (e encodable) DeepCopyObject() Object { - out := e - out.obj = e.obj.DeepCopyObject() - copy(out.versions, e.versions) - return out -} - -// NewEncodable creates an object that will be encoded with the provided codec on demand. -// Provided as a convenience for test cases dealing with internal objects. -func NewEncodable(e Encoder, obj Object, versions ...schema.GroupVersion) Object { - if _, ok := obj.(*Unknown); ok { - return obj - } - return encodable{e, obj, versions} -} - -func (e encodable) UnmarshalJSON(in []byte) error { - return errors.New("runtime.encodable cannot be unmarshalled from JSON") -} - -// Marshal may get called on pointers or values, so implement MarshalJSON on value. -// http://stackoverflow.com/questions/21390979/custom-marshaljson-never-gets-called-in-go -func (e encodable) MarshalJSON() ([]byte, error) { - return Encode(e.E, e.obj) -} - -// NewEncodableList creates an object that will be encoded with the provided codec on demand. -// Provided as a convenience for test cases dealing with internal objects. -func NewEncodableList(e Encoder, objects []Object, versions ...schema.GroupVersion) []Object { - out := make([]Object, len(objects)) - for i := range objects { - if _, ok := objects[i].(*Unknown); ok { - out[i] = objects[i] - continue - } - out[i] = NewEncodable(e, objects[i], versions...) - } - return out -} - -func (e *Unknown) UnmarshalJSON(in []byte) error { - if e == nil { - return errors.New("runtime.Unknown: UnmarshalJSON on nil pointer") - } - e.TypeMeta = TypeMeta{} - e.Raw = append(e.Raw[0:0], in...) - e.ContentEncoding = "" - e.ContentType = ContentTypeJSON - return nil -} - -// Marshal may get called on pointers or values, so implement MarshalJSON on value. -// http://stackoverflow.com/questions/21390979/custom-marshaljson-never-gets-called-in-go -func (e Unknown) MarshalJSON() ([]byte, error) { - // If ContentType is unset, we assume this is JSON. - if e.ContentType != "" && e.ContentType != ContentTypeJSON { - return nil, errors.New("runtime.Unknown: MarshalJSON on non-json data") - } - if e.Raw == nil { - return []byte("null"), nil - } - return e.Raw, nil -} - -func Convert_runtime_Object_To_runtime_RawExtension(in *Object, out *RawExtension, s conversion.Scope) error { - if in == nil { - out.Raw = []byte("null") - return nil - } - obj := *in - if unk, ok := obj.(*Unknown); ok { - if unk.Raw != nil { - out.Raw = unk.Raw - return nil - } - obj = out.Object - } - if obj == nil { - out.Raw = nil - return nil - } - out.Object = obj - return nil -} - -func Convert_runtime_RawExtension_To_runtime_Object(in *RawExtension, out *Object, s conversion.Scope) error { - if in.Object != nil { - *out = in.Object - return nil - } - data := in.Raw - if len(data) == 0 || (len(data) == 4 && string(data) == "null") { - *out = nil - return nil - } - *out = &Unknown{ - Raw: data, - // TODO: Set ContentEncoding and ContentType appropriately. - // Currently we set ContentTypeJSON to make tests passing. - ContentType: ContentTypeJSON, - } - return nil -} - -func RegisterEmbeddedConversions(s *Scheme) error { - if err := s.AddConversionFunc((*Object)(nil), (*RawExtension)(nil), func(a, b interface{}, scope conversion.Scope) error { - return Convert_runtime_Object_To_runtime_RawExtension(a.(*Object), b.(*RawExtension), scope) - }); err != nil { - return err - } - if err := s.AddConversionFunc((*RawExtension)(nil), (*Object)(nil), func(a, b interface{}, scope conversion.Scope) error { - return Convert_runtime_RawExtension_To_runtime_Object(a.(*RawExtension), b.(*Object), scope) - }); err != nil { - return err - } - return nil -} diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/error.go b/vendor/k8s.io/apimachinery/pkg/runtime/error.go deleted file mode 100644 index be0c5edc8..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/error.go +++ /dev/null @@ -1,151 +0,0 @@ -/* -Copyright 2014 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 runtime - -import ( - "fmt" - "reflect" - - "k8s.io/apimachinery/pkg/runtime/schema" -) - -type notRegisteredErr struct { - schemeName string - gvk schema.GroupVersionKind - target GroupVersioner - t reflect.Type -} - -func NewNotRegisteredErrForKind(schemeName string, gvk schema.GroupVersionKind) error { - return ¬RegisteredErr{schemeName: schemeName, gvk: gvk} -} - -func NewNotRegisteredErrForType(schemeName string, t reflect.Type) error { - return ¬RegisteredErr{schemeName: schemeName, t: t} -} - -func NewNotRegisteredErrForTarget(schemeName string, t reflect.Type, target GroupVersioner) error { - return ¬RegisteredErr{schemeName: schemeName, t: t, target: target} -} - -func NewNotRegisteredGVKErrForTarget(schemeName string, gvk schema.GroupVersionKind, target GroupVersioner) error { - return ¬RegisteredErr{schemeName: schemeName, gvk: gvk, target: target} -} - -func (k *notRegisteredErr) Error() string { - if k.t != nil && k.target != nil { - return fmt.Sprintf("%v is not suitable for converting to %q in scheme %q", k.t, k.target, k.schemeName) - } - nullGVK := schema.GroupVersionKind{} - if k.gvk != nullGVK && k.target != nil { - return fmt.Sprintf("%q is not suitable for converting to %q in scheme %q", k.gvk.GroupVersion(), k.target, k.schemeName) - } - if k.t != nil { - return fmt.Sprintf("no kind is registered for the type %v in scheme %q", k.t, k.schemeName) - } - if len(k.gvk.Kind) == 0 { - return fmt.Sprintf("no version %q has been registered in scheme %q", k.gvk.GroupVersion(), k.schemeName) - } - if k.gvk.Version == APIVersionInternal { - return fmt.Sprintf("no kind %q is registered for the internal version of group %q in scheme %q", k.gvk.Kind, k.gvk.Group, k.schemeName) - } - - return fmt.Sprintf("no kind %q is registered for version %q in scheme %q", k.gvk.Kind, k.gvk.GroupVersion(), k.schemeName) -} - -// IsNotRegisteredError returns true if the error indicates the provided -// object or input data is not registered. -func IsNotRegisteredError(err error) bool { - if err == nil { - return false - } - _, ok := err.(*notRegisteredErr) - return ok -} - -type missingKindErr struct { - data string -} - -func NewMissingKindErr(data string) error { - return &missingKindErr{data} -} - -func (k *missingKindErr) Error() string { - return fmt.Sprintf("Object 'Kind' is missing in '%s'", k.data) -} - -// IsMissingKind returns true if the error indicates that the provided object -// is missing a 'Kind' field. -func IsMissingKind(err error) bool { - if err == nil { - return false - } - _, ok := err.(*missingKindErr) - return ok -} - -type missingVersionErr struct { - data string -} - -func NewMissingVersionErr(data string) error { - return &missingVersionErr{data} -} - -func (k *missingVersionErr) Error() string { - return fmt.Sprintf("Object 'apiVersion' is missing in '%s'", k.data) -} - -// IsMissingVersion returns true if the error indicates that the provided object -// is missing a 'Version' field. -func IsMissingVersion(err error) bool { - if err == nil { - return false - } - _, ok := err.(*missingVersionErr) - return ok -} - -// strictDecodingError is a base error type that is returned by a strict Decoder such -// as UniversalStrictDecoder. -type strictDecodingError struct { - message string - data string -} - -// NewStrictDecodingError creates a new strictDecodingError object. -func NewStrictDecodingError(message string, data string) error { - return &strictDecodingError{ - message: message, - data: data, - } -} - -func (e *strictDecodingError) Error() string { - return fmt.Sprintf("strict decoder error for %s: %s", e.data, e.message) -} - -// IsStrictDecodingError returns true if the error indicates that the provided object -// strictness violations. -func IsStrictDecodingError(err error) bool { - if err == nil { - return false - } - _, ok := err.(*strictDecodingError) - return ok -} diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/extension.go b/vendor/k8s.io/apimachinery/pkg/runtime/extension.go deleted file mode 100644 index 9056397fa..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/extension.go +++ /dev/null @@ -1,51 +0,0 @@ -/* -Copyright 2014 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 runtime - -import ( - "bytes" - "encoding/json" - "errors" -) - -func (re *RawExtension) UnmarshalJSON(in []byte) error { - if re == nil { - return errors.New("runtime.RawExtension: UnmarshalJSON on nil pointer") - } - if !bytes.Equal(in, []byte("null")) { - re.Raw = append(re.Raw[0:0], in...) - } - return nil -} - -// MarshalJSON may get called on pointers or values, so implement MarshalJSON on value. -// http://stackoverflow.com/questions/21390979/custom-marshaljson-never-gets-called-in-go -func (re RawExtension) MarshalJSON() ([]byte, error) { - if re.Raw == nil { - // TODO: this is to support legacy behavior of JSONPrinter and YAMLPrinter, which - // expect to call json.Marshal on arbitrary versioned objects (even those not in - // the scheme). pkg/kubectl/resource#AsVersionedObjects and its interaction with - // kubectl get on objects not in the scheme needs to be updated to ensure that the - // objects that are not part of the scheme are correctly put into the right form. - if re.Object != nil { - return json.Marshal(re.Object) - } - return []byte("null"), nil - } - // TODO: Check whether ContentType is actually JSON before returning it. - return re.Raw, nil -} diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/generated.pb.go b/vendor/k8s.io/apimachinery/pkg/runtime/generated.pb.go deleted file mode 100644 index ac428d610..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/generated.pb.go +++ /dev/null @@ -1,846 +0,0 @@ -/* -Copyright 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. -*/ - -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/runtime/generated.proto - -package runtime - -import ( - fmt "fmt" - - io "io" - math "math" - math_bits "math/bits" - reflect "reflect" - strings "strings" - - proto "github.com/gogo/protobuf/proto" -) - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package - -func (m *RawExtension) Reset() { *m = RawExtension{} } -func (*RawExtension) ProtoMessage() {} -func (*RawExtension) Descriptor() ([]byte, []int) { - return fileDescriptor_9d3c45d7f546725c, []int{0} -} -func (m *RawExtension) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *RawExtension) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil -} -func (m *RawExtension) XXX_Merge(src proto.Message) { - xxx_messageInfo_RawExtension.Merge(m, src) -} -func (m *RawExtension) XXX_Size() int { - return m.Size() -} -func (m *RawExtension) XXX_DiscardUnknown() { - xxx_messageInfo_RawExtension.DiscardUnknown(m) -} - -var xxx_messageInfo_RawExtension proto.InternalMessageInfo - -func (m *TypeMeta) Reset() { *m = TypeMeta{} } -func (*TypeMeta) ProtoMessage() {} -func (*TypeMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_9d3c45d7f546725c, []int{1} -} -func (m *TypeMeta) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *TypeMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil -} -func (m *TypeMeta) XXX_Merge(src proto.Message) { - xxx_messageInfo_TypeMeta.Merge(m, src) -} -func (m *TypeMeta) XXX_Size() int { - return m.Size() -} -func (m *TypeMeta) XXX_DiscardUnknown() { - xxx_messageInfo_TypeMeta.DiscardUnknown(m) -} - -var xxx_messageInfo_TypeMeta proto.InternalMessageInfo - -func (m *Unknown) Reset() { *m = Unknown{} } -func (*Unknown) ProtoMessage() {} -func (*Unknown) Descriptor() ([]byte, []int) { - return fileDescriptor_9d3c45d7f546725c, []int{2} -} -func (m *Unknown) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Unknown) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil -} -func (m *Unknown) XXX_Merge(src proto.Message) { - xxx_messageInfo_Unknown.Merge(m, src) -} -func (m *Unknown) XXX_Size() int { - return m.Size() -} -func (m *Unknown) XXX_DiscardUnknown() { - xxx_messageInfo_Unknown.DiscardUnknown(m) -} - -var xxx_messageInfo_Unknown proto.InternalMessageInfo - -func init() { - proto.RegisterType((*RawExtension)(nil), "k8s.io.apimachinery.pkg.runtime.RawExtension") - proto.RegisterType((*TypeMeta)(nil), "k8s.io.apimachinery.pkg.runtime.TypeMeta") - proto.RegisterType((*Unknown)(nil), "k8s.io.apimachinery.pkg.runtime.Unknown") -} - -func init() { - proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/runtime/generated.proto", fileDescriptor_9d3c45d7f546725c) -} - -var fileDescriptor_9d3c45d7f546725c = []byte{ - // 378 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x8f, 0x4f, 0xab, 0x13, 0x31, - 0x14, 0xc5, 0x27, 0xaf, 0x85, 0x3e, 0xd3, 0xc2, 0x93, 0xb8, 0x70, 0x74, 0x91, 0x79, 0x74, 0xe5, - 0x5b, 0xbc, 0x04, 0x1e, 0x08, 0x6e, 0x3b, 0xa5, 0xa0, 0x88, 0x20, 0xc1, 0x3f, 0xe0, 0xca, 0x74, - 0x26, 0x4e, 0xc3, 0xd0, 0x9b, 0x21, 0xcd, 0x38, 0x76, 0xe7, 0x47, 0xf0, 0x63, 0x75, 0xd9, 0x65, - 0x57, 0xc5, 0x8e, 0x1f, 0xc2, 0xad, 0x34, 0x4d, 0x6b, 0xd5, 0x85, 0xbb, 0xe4, 0x9e, 0xf3, 0x3b, - 0xf7, 0x1e, 0xfc, 0xbc, 0x7c, 0xb6, 0x60, 0xda, 0xf0, 0xb2, 0x9e, 0x2a, 0x0b, 0xca, 0xa9, 0x05, - 0xff, 0xac, 0x20, 0x37, 0x96, 0x07, 0x41, 0x56, 0x7a, 0x2e, 0xb3, 0x99, 0x06, 0x65, 0x97, 0xbc, - 0x2a, 0x0b, 0x6e, 0x6b, 0x70, 0x7a, 0xae, 0x78, 0xa1, 0x40, 0x59, 0xe9, 0x54, 0xce, 0x2a, 0x6b, - 0x9c, 0x21, 0xc9, 0x01, 0x60, 0xe7, 0x00, 0xab, 0xca, 0x82, 0x05, 0xe0, 0xf1, 0x6d, 0xa1, 0xdd, - 0xac, 0x9e, 0xb2, 0xcc, 0xcc, 0x79, 0x61, 0x0a, 0xc3, 0x3d, 0x37, 0xad, 0x3f, 0xf9, 0x9f, 0xff, - 0xf8, 0xd7, 0x21, 0x6f, 0x78, 0x83, 0x07, 0x42, 0x36, 0x93, 0x2f, 0x4e, 0xc1, 0x42, 0x1b, 0x20, - 0x8f, 0x70, 0xc7, 0xca, 0x26, 0x46, 0xd7, 0xe8, 0xc9, 0x20, 0xed, 0xb5, 0xdb, 0xa4, 0x23, 0x64, - 0x23, 0xf6, 0xb3, 0xe1, 0x47, 0x7c, 0xf9, 0x66, 0x59, 0xa9, 0x57, 0xca, 0x49, 0x72, 0x87, 0xb1, - 0xac, 0xf4, 0x3b, 0x65, 0xf7, 0x90, 0x77, 0xdf, 0x4b, 0xc9, 0x6a, 0x9b, 0x44, 0xed, 0x36, 0xc1, - 0xa3, 0xd7, 0x2f, 0x82, 0x22, 0xce, 0x5c, 0xe4, 0x1a, 0x77, 0x4b, 0x0d, 0x79, 0x7c, 0xe1, 0xdd, - 0x83, 0xe0, 0xee, 0xbe, 0xd4, 0x90, 0x0b, 0xaf, 0x0c, 0x7f, 0x22, 0xdc, 0x7b, 0x0b, 0x25, 0x98, - 0x06, 0xc8, 0x7b, 0x7c, 0xe9, 0xc2, 0x36, 0x9f, 0xdf, 0xbf, 0xbb, 0x61, 0xff, 0xe9, 0xce, 0x8e, - 0xe7, 0xa5, 0xf7, 0x43, 0xf8, 0xe9, 0x60, 0x71, 0x0a, 0x3b, 0x36, 0xbc, 0xf8, 0xb7, 0x21, 0x19, - 0xe1, 0xab, 0xcc, 0x80, 0x53, 0xe0, 0x26, 0x90, 0x99, 0x5c, 0x43, 0x11, 0x77, 0xfc, 0xb1, 0x0f, - 0x43, 0xde, 0xd5, 0xf8, 0x4f, 0x59, 0xfc, 0xed, 0x27, 0x4f, 0x71, 0x3f, 0x8c, 0xf6, 0xab, 0xe3, - 0xae, 0xc7, 0x1f, 0x04, 0xbc, 0x3f, 0xfe, 0x2d, 0x89, 0x73, 0x5f, 0x7a, 0xbb, 0xda, 0xd1, 0x68, - 0xbd, 0xa3, 0xd1, 0x66, 0x47, 0xa3, 0xaf, 0x2d, 0x45, 0xab, 0x96, 0xa2, 0x75, 0x4b, 0xd1, 0xa6, - 0xa5, 0xe8, 0x7b, 0x4b, 0xd1, 0xb7, 0x1f, 0x34, 0xfa, 0xd0, 0x0b, 0x45, 0x7f, 0x05, 0x00, 0x00, - 0xff, 0xff, 0xe3, 0x33, 0x18, 0x0b, 0x50, 0x02, 0x00, 0x00, -} - -func (m *RawExtension) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *RawExtension) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *RawExtension) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Raw != nil { - i -= len(m.Raw) - copy(dAtA[i:], m.Raw) - i = encodeVarintGenerated(dAtA, i, uint64(len(m.Raw))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *TypeMeta) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *TypeMeta) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *TypeMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - i -= len(m.Kind) - copy(dAtA[i:], m.Kind) - i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind))) - i-- - dAtA[i] = 0x12 - i -= len(m.APIVersion) - copy(dAtA[i:], m.APIVersion) - i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIVersion))) - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil -} - -func (m *Unknown) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *Unknown) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Unknown) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - i -= len(m.ContentType) - copy(dAtA[i:], m.ContentType) - i = encodeVarintGenerated(dAtA, i, uint64(len(m.ContentType))) - i-- - dAtA[i] = 0x22 - i -= len(m.ContentEncoding) - copy(dAtA[i:], m.ContentEncoding) - i = encodeVarintGenerated(dAtA, i, uint64(len(m.ContentEncoding))) - i-- - dAtA[i] = 0x1a - if m.Raw != nil { - i -= len(m.Raw) - copy(dAtA[i:], m.Raw) - i = encodeVarintGenerated(dAtA, i, uint64(len(m.Raw))) - i-- - dAtA[i] = 0x12 - } - { - size, err := m.TypeMeta.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGenerated(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil -} - -func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int { - offset -= sovGenerated(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *RawExtension) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Raw != nil { - l = len(m.Raw) - n += 1 + l + sovGenerated(uint64(l)) - } - return n -} - -func (m *TypeMeta) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.APIVersion) - n += 1 + l + sovGenerated(uint64(l)) - l = len(m.Kind) - n += 1 + l + sovGenerated(uint64(l)) - return n -} - -func (m *Unknown) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = m.TypeMeta.Size() - n += 1 + l + sovGenerated(uint64(l)) - if m.Raw != nil { - l = len(m.Raw) - n += 1 + l + sovGenerated(uint64(l)) - } - l = len(m.ContentEncoding) - n += 1 + l + sovGenerated(uint64(l)) - l = len(m.ContentType) - n += 1 + l + sovGenerated(uint64(l)) - return n -} - -func sovGenerated(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozGenerated(x uint64) (n int) { - return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (this *RawExtension) String() string { - if this == nil { - return "nil" - } - s := strings.Join([]string{`&RawExtension{`, - `Raw:` + valueToStringGenerated(this.Raw) + `,`, - `}`, - }, "") - return s -} -func (this *TypeMeta) String() string { - if this == nil { - return "nil" - } - s := strings.Join([]string{`&TypeMeta{`, - `APIVersion:` + fmt.Sprintf("%v", this.APIVersion) + `,`, - `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`, - `}`, - }, "") - return s -} -func (this *Unknown) String() string { - if this == nil { - return "nil" - } - s := strings.Join([]string{`&Unknown{`, - `TypeMeta:` + strings.Replace(strings.Replace(this.TypeMeta.String(), "TypeMeta", "TypeMeta", 1), `&`, ``, 1) + `,`, - `Raw:` + valueToStringGenerated(this.Raw) + `,`, - `ContentEncoding:` + fmt.Sprintf("%v", this.ContentEncoding) + `,`, - `ContentType:` + fmt.Sprintf("%v", this.ContentType) + `,`, - `}`, - }, "") - return s -} -func valueToStringGenerated(v interface{}) string { - rv := reflect.ValueOf(v) - if rv.IsNil() { - return "nil" - } - pv := reflect.Indirect(rv).Interface() - return fmt.Sprintf("*%v", pv) -} -func (m *RawExtension) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: RawExtension: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: RawExtension: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Raw", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthGenerated - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthGenerated - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Raw = append(m.Raw[:0], dAtA[iNdEx:postIndex]...) - if m.Raw == nil { - m.Raw = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGenerated(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGenerated - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *TypeMeta) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: TypeMeta: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: TypeMeta: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthGenerated - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGenerated - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.APIVersion = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthGenerated - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGenerated - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Kind = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGenerated(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGenerated - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Unknown) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: Unknown: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Unknown: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TypeMeta", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGenerated - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGenerated - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.TypeMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Raw", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthGenerated - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthGenerated - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Raw = append(m.Raw[:0], dAtA[iNdEx:postIndex]...) - if m.Raw == nil { - m.Raw = []byte{} - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ContentEncoding", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthGenerated - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGenerated - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ContentEncoding = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ContentType", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthGenerated - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGenerated - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ContentType = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGenerated(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGenerated - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipGenerated(dAtA []byte) (n int, err error) { - l := len(dAtA) - iNdEx := 0 - depth := 0 - for iNdEx < l { - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowGenerated - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - wireType := int(wire & 0x7) - switch wireType { - case 0: - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowGenerated - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - iNdEx++ - if dAtA[iNdEx-1] < 0x80 { - break - } - } - case 1: - iNdEx += 8 - case 2: - var length int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowGenerated - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - length |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if length < 0 { - return 0, ErrInvalidLengthGenerated - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupGenerated - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthGenerated - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group") -) diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/generated.proto b/vendor/k8s.io/apimachinery/pkg/runtime/generated.proto deleted file mode 100644 index 3b25391fa..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/generated.proto +++ /dev/null @@ -1,127 +0,0 @@ -/* -Copyright 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. -*/ - - -// This file was autogenerated by go-to-protobuf. Do not edit it manually! - -syntax = "proto2"; - -package k8s.io.apimachinery.pkg.runtime; - -// Package-wide variables from generator "generated". -option go_package = "runtime"; - -// RawExtension is used to hold extensions in external versions. -// -// To use this, make a field which has RawExtension as its type in your external, versioned -// struct, and Object in your internal struct. You also need to register your -// various plugin types. -// -// // Internal package: -// type MyAPIObject struct { -// runtime.TypeMeta `json:",inline"` -// MyPlugin runtime.Object `json:"myPlugin"` -// } -// type PluginA struct { -// AOption string `json:"aOption"` -// } -// -// // External package: -// type MyAPIObject struct { -// runtime.TypeMeta `json:",inline"` -// MyPlugin runtime.RawExtension `json:"myPlugin"` -// } -// type PluginA struct { -// AOption string `json:"aOption"` -// } -// -// // On the wire, the JSON will look something like this: -// { -// "kind":"MyAPIObject", -// "apiVersion":"v1", -// "myPlugin": { -// "kind":"PluginA", -// "aOption":"foo", -// }, -// } -// -// So what happens? Decode first uses json or yaml to unmarshal the serialized data into -// your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. -// The next step is to copy (using pkg/conversion) into the internal struct. The runtime -// package's DefaultScheme has conversion functions installed which will unpack the -// JSON stored in RawExtension, turning it into the correct object type, and storing it -// in the Object. (TODO: In the case where the object is of an unknown type, a -// runtime.Unknown object will be created and stored.) -// -// +k8s:deepcopy-gen=true -// +protobuf=true -// +k8s:openapi-gen=true -message RawExtension { - // Raw is the underlying serialization of this object. - // - // TODO: Determine how to detect ContentType and ContentEncoding of 'Raw' data. - optional bytes raw = 1; -} - -// TypeMeta is shared by all top level objects. The proper way to use it is to inline it in your type, -// like this: -// type MyAwesomeAPIObject struct { -// runtime.TypeMeta `json:",inline"` -// ... // other fields -// } -// func (obj *MyAwesomeAPIObject) SetGroupVersionKind(gvk *metav1.GroupVersionKind) { metav1.UpdateTypeMeta(obj,gvk) }; GroupVersionKind() *GroupVersionKind -// -// TypeMeta is provided here for convenience. You may use it directly from this package or define -// your own with the same fields. -// -// +k8s:deepcopy-gen=false -// +protobuf=true -// +k8s:openapi-gen=true -message TypeMeta { - // +optional - optional string apiVersion = 1; - - // +optional - optional string kind = 2; -} - -// Unknown allows api objects with unknown types to be passed-through. This can be used -// to deal with the API objects from a plug-in. Unknown objects still have functioning -// TypeMeta features-- kind, version, etc. -// TODO: Make this object have easy access to field based accessors and settors for -// metadata and field mutatation. -// -// +k8s:deepcopy-gen=true -// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object -// +protobuf=true -// +k8s:openapi-gen=true -message Unknown { - optional TypeMeta typeMeta = 1; - - // Raw will hold the complete serialized object which couldn't be matched - // with a registered type. Most likely, nothing should be done with this - // except for passing it through the system. - optional bytes raw = 2; - - // ContentEncoding is encoding used to encode 'Raw' data. - // Unspecified means no encoding. - optional string contentEncoding = 3; - - // ContentType is serialization method used to serialize 'Raw'. - // Unspecified means ContentTypeJSON. - optional string contentType = 4; -} - diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/helper.go b/vendor/k8s.io/apimachinery/pkg/runtime/helper.go deleted file mode 100644 index 7bd1a3a6a..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/helper.go +++ /dev/null @@ -1,259 +0,0 @@ -/* -Copyright 2014 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 runtime - -import ( - "fmt" - "io" - "reflect" - - "k8s.io/apimachinery/pkg/conversion" - "k8s.io/apimachinery/pkg/runtime/schema" - "k8s.io/apimachinery/pkg/util/errors" -) - -// unsafeObjectConvertor implements ObjectConvertor using the unsafe conversion path. -type unsafeObjectConvertor struct { - *Scheme -} - -var _ ObjectConvertor = unsafeObjectConvertor{} - -// ConvertToVersion converts in to the provided outVersion without copying the input first, which -// is only safe if the output object is not mutated or reused. -func (c unsafeObjectConvertor) ConvertToVersion(in Object, outVersion GroupVersioner) (Object, error) { - return c.Scheme.UnsafeConvertToVersion(in, outVersion) -} - -// UnsafeObjectConvertor performs object conversion without copying the object structure, -// for use when the converted object will not be reused or mutated. Primarily for use within -// versioned codecs, which use the external object for serialization but do not return it. -func UnsafeObjectConvertor(scheme *Scheme) ObjectConvertor { - return unsafeObjectConvertor{scheme} -} - -// SetField puts the value of src, into fieldName, which must be a member of v. -// The value of src must be assignable to the field. -func SetField(src interface{}, v reflect.Value, fieldName string) error { - field := v.FieldByName(fieldName) - if !field.IsValid() { - return fmt.Errorf("couldn't find %v field in %T", fieldName, v.Interface()) - } - srcValue := reflect.ValueOf(src) - if srcValue.Type().AssignableTo(field.Type()) { - field.Set(srcValue) - return nil - } - if srcValue.Type().ConvertibleTo(field.Type()) { - field.Set(srcValue.Convert(field.Type())) - return nil - } - return fmt.Errorf("couldn't assign/convert %v to %v", srcValue.Type(), field.Type()) -} - -// Field puts the value of fieldName, which must be a member of v, into dest, -// which must be a variable to which this field's value can be assigned. -func Field(v reflect.Value, fieldName string, dest interface{}) error { - field := v.FieldByName(fieldName) - if !field.IsValid() { - return fmt.Errorf("couldn't find %v field in %T", fieldName, v.Interface()) - } - destValue, err := conversion.EnforcePtr(dest) - if err != nil { - return err - } - if field.Type().AssignableTo(destValue.Type()) { - destValue.Set(field) - return nil - } - if field.Type().ConvertibleTo(destValue.Type()) { - destValue.Set(field.Convert(destValue.Type())) - return nil - } - return fmt.Errorf("couldn't assign/convert %v to %v", field.Type(), destValue.Type()) -} - -// FieldPtr puts the address of fieldName, which must be a member of v, -// into dest, which must be an address of a variable to which this field's -// address can be assigned. -func FieldPtr(v reflect.Value, fieldName string, dest interface{}) error { - field := v.FieldByName(fieldName) - if !field.IsValid() { - return fmt.Errorf("couldn't find %v field in %T", fieldName, v.Interface()) - } - v, err := conversion.EnforcePtr(dest) - if err != nil { - return err - } - field = field.Addr() - if field.Type().AssignableTo(v.Type()) { - v.Set(field) - return nil - } - if field.Type().ConvertibleTo(v.Type()) { - v.Set(field.Convert(v.Type())) - return nil - } - return fmt.Errorf("couldn't assign/convert %v to %v", field.Type(), v.Type()) -} - -// EncodeList ensures that each object in an array is converted to a Unknown{} in serialized form. -// TODO: accept a content type. -func EncodeList(e Encoder, objects []Object) error { - var errs []error - for i := range objects { - data, err := Encode(e, objects[i]) - if err != nil { - errs = append(errs, err) - continue - } - // TODO: Set ContentEncoding and ContentType. - objects[i] = &Unknown{Raw: data} - } - return errors.NewAggregate(errs) -} - -func decodeListItem(obj *Unknown, decoders []Decoder) (Object, error) { - for _, decoder := range decoders { - // TODO: Decode based on ContentType. - obj, err := Decode(decoder, obj.Raw) - if err != nil { - if IsNotRegisteredError(err) { - continue - } - return nil, err - } - return obj, nil - } - // could not decode, so leave the object as Unknown, but give the decoders the - // chance to set Unknown.TypeMeta if it is available. - for _, decoder := range decoders { - if err := DecodeInto(decoder, obj.Raw, obj); err == nil { - return obj, nil - } - } - return obj, nil -} - -// DecodeList alters the list in place, attempting to decode any objects found in -// the list that have the Unknown type. Any errors that occur are returned -// after the entire list is processed. Decoders are tried in order. -func DecodeList(objects []Object, decoders ...Decoder) []error { - errs := []error(nil) - for i, obj := range objects { - switch t := obj.(type) { - case *Unknown: - decoded, err := decodeListItem(t, decoders) - if err != nil { - errs = append(errs, err) - break - } - objects[i] = decoded - } - } - return errs -} - -// MultiObjectTyper returns the types of objects across multiple schemes in order. -type MultiObjectTyper []ObjectTyper - -var _ ObjectTyper = MultiObjectTyper{} - -func (m MultiObjectTyper) ObjectKinds(obj Object) (gvks []schema.GroupVersionKind, unversionedType bool, err error) { - for _, t := range m { - gvks, unversionedType, err = t.ObjectKinds(obj) - if err == nil { - return - } - } - return -} - -func (m MultiObjectTyper) Recognizes(gvk schema.GroupVersionKind) bool { - for _, t := range m { - if t.Recognizes(gvk) { - return true - } - } - return false -} - -// SetZeroValue would set the object of objPtr to zero value of its type. -func SetZeroValue(objPtr Object) error { - v, err := conversion.EnforcePtr(objPtr) - if err != nil { - return err - } - v.Set(reflect.Zero(v.Type())) - return nil -} - -// DefaultFramer is valid for any stream that can read objects serially without -// any separation in the stream. -var DefaultFramer = defaultFramer{} - -type defaultFramer struct{} - -func (defaultFramer) NewFrameReader(r io.ReadCloser) io.ReadCloser { return r } -func (defaultFramer) NewFrameWriter(w io.Writer) io.Writer { return w } - -// WithVersionEncoder serializes an object and ensures the GVK is set. -type WithVersionEncoder struct { - Version GroupVersioner - Encoder - ObjectTyper -} - -// Encode does not do conversion. It sets the gvk during serialization. -func (e WithVersionEncoder) Encode(obj Object, stream io.Writer) error { - gvks, _, err := e.ObjectTyper.ObjectKinds(obj) - if err != nil { - if IsNotRegisteredError(err) { - return e.Encoder.Encode(obj, stream) - } - return err - } - kind := obj.GetObjectKind() - oldGVK := kind.GroupVersionKind() - gvk := gvks[0] - if e.Version != nil { - preferredGVK, ok := e.Version.KindForGroupVersionKinds(gvks) - if ok { - gvk = preferredGVK - } - } - kind.SetGroupVersionKind(gvk) - err = e.Encoder.Encode(obj, stream) - kind.SetGroupVersionKind(oldGVK) - return err -} - -// WithoutVersionDecoder clears the group version kind of a deserialized object. -type WithoutVersionDecoder struct { - Decoder -} - -// Decode does not do conversion. It removes the gvk during deserialization. -func (d WithoutVersionDecoder) Decode(data []byte, defaults *schema.GroupVersionKind, into Object) (Object, *schema.GroupVersionKind, error) { - obj, gvk, err := d.Decoder.Decode(data, defaults, into) - if obj != nil { - kind := obj.GetObjectKind() - // clearing the gvk is just a convention of a codec - kind.SetGroupVersionKind(schema.GroupVersionKind{}) - } - return obj, gvk, err -} diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/interfaces.go b/vendor/k8s.io/apimachinery/pkg/runtime/interfaces.go deleted file mode 100644 index 3e1fab1d1..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/interfaces.go +++ /dev/null @@ -1,344 +0,0 @@ -/* -Copyright 2014 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 runtime - -import ( - "io" - "net/url" - - "k8s.io/apimachinery/pkg/runtime/schema" -) - -const ( - // APIVersionInternal may be used if you are registering a type that should not - // be considered stable or serialized - it is a convention only and has no - // special behavior in this package. - APIVersionInternal = "__internal" -) - -// GroupVersioner refines a set of possible conversion targets into a single option. -type GroupVersioner interface { - // KindForGroupVersionKinds returns a desired target group version kind for the given input, or returns ok false if no - // target is known. In general, if the return target is not in the input list, the caller is expected to invoke - // Scheme.New(target) and then perform a conversion between the current Go type and the destination Go type. - // Sophisticated implementations may use additional information about the input kinds to pick a destination kind. - KindForGroupVersionKinds(kinds []schema.GroupVersionKind) (target schema.GroupVersionKind, ok bool) - // Identifier returns string representation of the object. - // Identifiers of two different encoders should be equal only if for every input - // kinds they return the same result. - Identifier() string -} - -// Identifier represents an identifier. -// Identitier of two different objects should be equal if and only if for every -// input the output they produce is exactly the same. -type Identifier string - -// Encoder writes objects to a serialized form -type Encoder interface { - // Encode writes an object to a stream. Implementations may return errors if the versions are - // incompatible, or if no conversion is defined. - Encode(obj Object, w io.Writer) error - // Identifier returns an identifier of the encoder. - // Identifiers of two different encoders should be equal if and only if for every input - // object it will be encoded to the same representation by both of them. - // - // Identifier is intended for use with CacheableObject#CacheEncode method. In order to - // correctly handle CacheableObject, Encode() method should look similar to below, where - // doEncode() is the encoding logic of implemented encoder: - // func (e *MyEncoder) Encode(obj Object, w io.Writer) error { - // if co, ok := obj.(CacheableObject); ok { - // return co.CacheEncode(e.Identifier(), e.doEncode, w) - // } - // return e.doEncode(obj, w) - // } - Identifier() Identifier -} - -// Decoder attempts to load an object from data. -type Decoder interface { - // Decode attempts to deserialize the provided data using either the innate typing of the scheme or the - // default kind, group, and version provided. It returns a decoded object as well as the kind, group, and - // version from the serialized data, or an error. If into is non-nil, it will be used as the target type - // and implementations may choose to use it rather than reallocating an object. However, the object is not - // guaranteed to be populated. The returned object is not guaranteed to match into. If defaults are - // provided, they are applied to the data by default. If no defaults or partial defaults are provided, the - // type of the into may be used to guide conversion decisions. - Decode(data []byte, defaults *schema.GroupVersionKind, into Object) (Object, *schema.GroupVersionKind, error) -} - -// Serializer is the core interface for transforming objects into a serialized format and back. -// Implementations may choose to perform conversion of the object, but no assumptions should be made. -type Serializer interface { - Encoder - Decoder -} - -// Codec is a Serializer that deals with the details of versioning objects. It offers the same -// interface as Serializer, so this is a marker to consumers that care about the version of the objects -// they receive. -type Codec Serializer - -// ParameterCodec defines methods for serializing and deserializing API objects to url.Values and -// performing any necessary conversion. Unlike the normal Codec, query parameters are not self describing -// and the desired version must be specified. -type ParameterCodec interface { - // DecodeParameters takes the given url.Values in the specified group version and decodes them - // into the provided object, or returns an error. - DecodeParameters(parameters url.Values, from schema.GroupVersion, into Object) error - // EncodeParameters encodes the provided object as query parameters or returns an error. - EncodeParameters(obj Object, to schema.GroupVersion) (url.Values, error) -} - -// Framer is a factory for creating readers and writers that obey a particular framing pattern. -type Framer interface { - NewFrameReader(r io.ReadCloser) io.ReadCloser - NewFrameWriter(w io.Writer) io.Writer -} - -// SerializerInfo contains information about a specific serialization format -type SerializerInfo struct { - // MediaType is the value that represents this serializer over the wire. - MediaType string - // MediaTypeType is the first part of the MediaType ("application" in "application/json"). - MediaTypeType string - // MediaTypeSubType is the second part of the MediaType ("json" in "application/json"). - MediaTypeSubType string - // EncodesAsText indicates this serializer can be encoded to UTF-8 safely. - EncodesAsText bool - // Serializer is the individual object serializer for this media type. - Serializer Serializer - // PrettySerializer, if set, can serialize this object in a form biased towards - // readability. - PrettySerializer Serializer - // StreamSerializer, if set, describes the streaming serialization format - // for this media type. - StreamSerializer *StreamSerializerInfo -} - -// StreamSerializerInfo contains information about a specific stream serialization format -type StreamSerializerInfo struct { - // EncodesAsText indicates this serializer can be encoded to UTF-8 safely. - EncodesAsText bool - // Serializer is the top level object serializer for this type when streaming - Serializer - // Framer is the factory for retrieving streams that separate objects on the wire - Framer -} - -// NegotiatedSerializer is an interface used for obtaining encoders, decoders, and serializers -// for multiple supported media types. This would commonly be accepted by a server component -// that performs HTTP content negotiation to accept multiple formats. -type NegotiatedSerializer interface { - // SupportedMediaTypes is the media types supported for reading and writing single objects. - SupportedMediaTypes() []SerializerInfo - - // EncoderForVersion returns an encoder that ensures objects being written to the provided - // serializer are in the provided group version. - EncoderForVersion(serializer Encoder, gv GroupVersioner) Encoder - // DecoderForVersion returns a decoder that ensures objects being read by the provided - // serializer are in the provided group version by default. - DecoderToVersion(serializer Decoder, gv GroupVersioner) Decoder -} - -// ClientNegotiator handles turning an HTTP content type into the appropriate encoder. -// Use NewClientNegotiator or NewVersionedClientNegotiator to create this interface from -// a NegotiatedSerializer. -type ClientNegotiator interface { - // Encoder returns the appropriate encoder for the provided contentType (e.g. application/json) - // and any optional mediaType parameters (e.g. pretty=1), or an error. If no serializer is found - // a NegotiateError will be returned. The current client implementations consider params to be - // optional modifiers to the contentType and will ignore unrecognized parameters. - Encoder(contentType string, params map[string]string) (Encoder, error) - // Decoder returns the appropriate decoder for the provided contentType (e.g. application/json) - // and any optional mediaType parameters (e.g. pretty=1), or an error. If no serializer is found - // a NegotiateError will be returned. The current client implementations consider params to be - // optional modifiers to the contentType and will ignore unrecognized parameters. - Decoder(contentType string, params map[string]string) (Decoder, error) - // StreamDecoder returns the appropriate stream decoder for the provided contentType (e.g. - // application/json) and any optional mediaType parameters (e.g. pretty=1), or an error. If no - // serializer is found a NegotiateError will be returned. The Serializer and Framer will always - // be returned if a Decoder is returned. The current client implementations consider params to be - // optional modifiers to the contentType and will ignore unrecognized parameters. - StreamDecoder(contentType string, params map[string]string) (Decoder, Serializer, Framer, error) -} - -// StorageSerializer is an interface used for obtaining encoders, decoders, and serializers -// that can read and write data at rest. This would commonly be used by client tools that must -// read files, or server side storage interfaces that persist restful objects. -type StorageSerializer interface { - // SupportedMediaTypes are the media types supported for reading and writing objects. - SupportedMediaTypes() []SerializerInfo - - // UniversalDeserializer returns a Serializer that can read objects in multiple supported formats - // by introspecting the data at rest. - UniversalDeserializer() Decoder - - // EncoderForVersion returns an encoder that ensures objects being written to the provided - // serializer are in the provided group version. - EncoderForVersion(serializer Encoder, gv GroupVersioner) Encoder - // DecoderForVersion returns a decoder that ensures objects being read by the provided - // serializer are in the provided group version by default. - DecoderToVersion(serializer Decoder, gv GroupVersioner) Decoder -} - -// NestedObjectEncoder is an optional interface that objects may implement to be given -// an opportunity to encode any nested Objects / RawExtensions during serialization. -type NestedObjectEncoder interface { - EncodeNestedObjects(e Encoder) error -} - -// NestedObjectDecoder is an optional interface that objects may implement to be given -// an opportunity to decode any nested Objects / RawExtensions during serialization. -type NestedObjectDecoder interface { - DecodeNestedObjects(d Decoder) error -} - -/////////////////////////////////////////////////////////////////////////////// -// Non-codec interfaces - -type ObjectDefaulter interface { - // Default takes an object (must be a pointer) and applies any default values. - // Defaulters may not error. - Default(in Object) -} - -type ObjectVersioner interface { - ConvertToVersion(in Object, gv GroupVersioner) (out Object, err error) -} - -// ObjectConvertor converts an object to a different version. -type ObjectConvertor interface { - // Convert attempts to convert one object into another, or returns an error. This - // method does not mutate the in object, but the in and out object might share data structures, - // i.e. the out object cannot be mutated without mutating the in object as well. - // The context argument will be passed to all nested conversions. - Convert(in, out, context interface{}) error - // ConvertToVersion takes the provided object and converts it the provided version. This - // method does not mutate the in object, but the in and out object might share data structures, - // i.e. the out object cannot be mutated without mutating the in object as well. - // This method is similar to Convert() but handles specific details of choosing the correct - // output version. - ConvertToVersion(in Object, gv GroupVersioner) (out Object, err error) - ConvertFieldLabel(gvk schema.GroupVersionKind, label, value string) (string, string, error) -} - -// ObjectTyper contains methods for extracting the APIVersion and Kind -// of objects. -type ObjectTyper interface { - // ObjectKinds returns the all possible group,version,kind of the provided object, true if - // the object is unversioned, or an error if the object is not recognized - // (IsNotRegisteredError will return true). - ObjectKinds(Object) ([]schema.GroupVersionKind, bool, error) - // Recognizes returns true if the scheme is able to handle the provided version and kind, - // or more precisely that the provided version is a possible conversion or decoding - // target. - Recognizes(gvk schema.GroupVersionKind) bool -} - -// ObjectCreater contains methods for instantiating an object by kind and version. -type ObjectCreater interface { - New(kind schema.GroupVersionKind) (out Object, err error) -} - -// EquivalentResourceMapper provides information about resources that address the same underlying data as a specified resource -type EquivalentResourceMapper interface { - // EquivalentResourcesFor returns a list of resources that address the same underlying data as resource. - // If subresource is specified, only equivalent resources which also have the same subresource are included. - // The specified resource can be included in the returned list. - EquivalentResourcesFor(resource schema.GroupVersionResource, subresource string) []schema.GroupVersionResource - // KindFor returns the kind expected by the specified resource[/subresource]. - // A zero value is returned if the kind is unknown. - KindFor(resource schema.GroupVersionResource, subresource string) schema.GroupVersionKind -} - -// EquivalentResourceRegistry provides an EquivalentResourceMapper interface, -// and allows registering known resource[/subresource] -> kind -type EquivalentResourceRegistry interface { - EquivalentResourceMapper - // RegisterKindFor registers the existence of the specified resource[/subresource] along with its expected kind. - RegisterKindFor(resource schema.GroupVersionResource, subresource string, kind schema.GroupVersionKind) -} - -// ResourceVersioner provides methods for setting and retrieving -// the resource version from an API object. -type ResourceVersioner interface { - SetResourceVersion(obj Object, version string) error - ResourceVersion(obj Object) (string, error) -} - -// SelfLinker provides methods for setting and retrieving the SelfLink field of an API object. -type SelfLinker interface { - SetSelfLink(obj Object, selfLink string) error - SelfLink(obj Object) (string, error) - - // Knowing Name is sometimes necessary to use a SelfLinker. - Name(obj Object) (string, error) - // Knowing Namespace is sometimes necessary to use a SelfLinker - Namespace(obj Object) (string, error) -} - -// Object interface must be supported by all API types registered with Scheme. Since objects in a scheme are -// expected to be serialized to the wire, the interface an Object must provide to the Scheme allows -// serializers to set the kind, version, and group the object is represented as. An Object may choose -// to return a no-op ObjectKindAccessor in cases where it is not expected to be serialized. -type Object interface { - GetObjectKind() schema.ObjectKind - DeepCopyObject() Object -} - -// CacheableObject allows an object to cache its different serializations -// to avoid performing the same serialization multiple times. -type CacheableObject interface { - // CacheEncode writes an object to a stream. The <encode> function will - // be used in case of cache miss. The <encode> function takes ownership - // of the object. - // If CacheableObject is a wrapper, then deep-copy of the wrapped object - // should be passed to <encode> function. - // CacheEncode assumes that for two different calls with the same <id>, - // <encode> function will also be the same. - CacheEncode(id Identifier, encode func(Object, io.Writer) error, w io.Writer) error - // GetObject returns a deep-copy of an object to be encoded - the caller of - // GetObject() is the owner of returned object. The reason for making a copy - // is to avoid bugs, where caller modifies the object and forgets to copy it, - // thus modifying the object for everyone. - // The object returned by GetObject should be the same as the one that is supposed - // to be passed to <encode> function in CacheEncode method. - // If CacheableObject is a wrapper, the copy of wrapped object should be returned. - GetObject() Object -} - -// Unstructured objects store values as map[string]interface{}, with only values that can be serialized -// to JSON allowed. -type Unstructured interface { - Object - // NewEmptyInstance returns a new instance of the concrete type containing only kind/apiVersion and no other data. - // This should be called instead of reflect.New() for unstructured types because the go type alone does not preserve kind/apiVersion info. - NewEmptyInstance() Unstructured - // UnstructuredContent returns a non-nil map with this object's contents. Values may be - // []interface{}, map[string]interface{}, or any primitive type. Contents are typically serialized to - // and from JSON. SetUnstructuredContent should be used to mutate the contents. - UnstructuredContent() map[string]interface{} - // SetUnstructuredContent updates the object content to match the provided map. - SetUnstructuredContent(map[string]interface{}) - // IsList returns true if this type is a list or matches the list convention - has an array called "items". - IsList() bool - // EachListItem should pass a single item out of the list as an Object to the provided function. Any - // error should terminate the iteration. If IsList() returns false, this method should return an error - // instead of calling the provided function. - EachListItem(func(Object) error) error -} diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/mapper.go b/vendor/k8s.io/apimachinery/pkg/runtime/mapper.go deleted file mode 100644 index 3ff84611a..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/mapper.go +++ /dev/null @@ -1,98 +0,0 @@ -/* -Copyright 2019 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 runtime - -import ( - "sync" - - "k8s.io/apimachinery/pkg/runtime/schema" -) - -type equivalentResourceRegistry struct { - // keyFunc computes a key for the specified resource (this allows honoring colocated resources across API groups). - // if null, or if "" is returned, resource.String() is used as the key - keyFunc func(resource schema.GroupResource) string - // resources maps key -> subresource -> equivalent resources (subresource is not included in the returned resources). - // main resources are stored with subresource="". - resources map[string]map[string][]schema.GroupVersionResource - // kinds maps resource -> subresource -> kind - kinds map[schema.GroupVersionResource]map[string]schema.GroupVersionKind - // keys caches the computed key for each GroupResource - keys map[schema.GroupResource]string - - mutex sync.RWMutex -} - -var _ EquivalentResourceMapper = (*equivalentResourceRegistry)(nil) -var _ EquivalentResourceRegistry = (*equivalentResourceRegistry)(nil) - -// NewEquivalentResourceRegistry creates a resource registry that considers all versions of a GroupResource to be equivalent. -func NewEquivalentResourceRegistry() EquivalentResourceRegistry { - return &equivalentResourceRegistry{} -} - -// NewEquivalentResourceRegistryWithIdentity creates a resource mapper with a custom identity function. -// If "" is returned by the function, GroupResource#String is used as the identity. -// GroupResources with the same identity string are considered equivalent. -func NewEquivalentResourceRegistryWithIdentity(keyFunc func(schema.GroupResource) string) EquivalentResourceRegistry { - return &equivalentResourceRegistry{keyFunc: keyFunc} -} - -func (r *equivalentResourceRegistry) EquivalentResourcesFor(resource schema.GroupVersionResource, subresource string) []schema.GroupVersionResource { - r.mutex.RLock() - defer r.mutex.RUnlock() - return r.resources[r.keys[resource.GroupResource()]][subresource] -} -func (r *equivalentResourceRegistry) KindFor(resource schema.GroupVersionResource, subresource string) schema.GroupVersionKind { - r.mutex.RLock() - defer r.mutex.RUnlock() - return r.kinds[resource][subresource] -} -func (r *equivalentResourceRegistry) RegisterKindFor(resource schema.GroupVersionResource, subresource string, kind schema.GroupVersionKind) { - r.mutex.Lock() - defer r.mutex.Unlock() - if r.kinds == nil { - r.kinds = map[schema.GroupVersionResource]map[string]schema.GroupVersionKind{} - } - if r.kinds[resource] == nil { - r.kinds[resource] = map[string]schema.GroupVersionKind{} - } - r.kinds[resource][subresource] = kind - - // get the shared key of the parent resource - key := "" - gr := resource.GroupResource() - if r.keyFunc != nil { - key = r.keyFunc(gr) - } - if key == "" { - key = gr.String() - } - - if r.keys == nil { - r.keys = map[schema.GroupResource]string{} - } - r.keys[gr] = key - - if r.resources == nil { - r.resources = map[string]map[string][]schema.GroupVersionResource{} - } - if r.resources[key] == nil { - r.resources[key] = map[string][]schema.GroupVersionResource{} - } - r.resources[key][subresource] = append(r.resources[key][subresource], resource) -} diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/negotiate.go b/vendor/k8s.io/apimachinery/pkg/runtime/negotiate.go deleted file mode 100644 index 3ab119b0a..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/negotiate.go +++ /dev/null @@ -1,113 +0,0 @@ -/* -Copyright 2019 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 runtime - -import ( - "fmt" - - "k8s.io/apimachinery/pkg/runtime/schema" -) - -// NegotiateError is returned when a ClientNegotiator is unable to locate -// a serializer for the requested operation. -type NegotiateError struct { - ContentType string - Stream bool -} - -func (e NegotiateError) Error() string { - if e.Stream { - return fmt.Sprintf("no stream serializers registered for %s", e.ContentType) - } - return fmt.Sprintf("no serializers registered for %s", e.ContentType) -} - -type clientNegotiator struct { - serializer NegotiatedSerializer - encode, decode GroupVersioner -} - -func (n *clientNegotiator) Encoder(contentType string, params map[string]string) (Encoder, error) { - // TODO: `pretty=1` is handled in NegotiateOutputMediaType, consider moving it to this method - // if client negotiators truly need to use it - mediaTypes := n.serializer.SupportedMediaTypes() - info, ok := SerializerInfoForMediaType(mediaTypes, contentType) - if !ok { - if len(contentType) != 0 || len(mediaTypes) == 0 { - return nil, NegotiateError{ContentType: contentType} - } - info = mediaTypes[0] - } - return n.serializer.EncoderForVersion(info.Serializer, n.encode), nil -} - -func (n *clientNegotiator) Decoder(contentType string, params map[string]string) (Decoder, error) { - mediaTypes := n.serializer.SupportedMediaTypes() - info, ok := SerializerInfoForMediaType(mediaTypes, contentType) - if !ok { - if len(contentType) != 0 || len(mediaTypes) == 0 { - return nil, NegotiateError{ContentType: contentType} - } - info = mediaTypes[0] - } - return n.serializer.DecoderToVersion(info.Serializer, n.decode), nil -} - -func (n *clientNegotiator) StreamDecoder(contentType string, params map[string]string) (Decoder, Serializer, Framer, error) { - mediaTypes := n.serializer.SupportedMediaTypes() - info, ok := SerializerInfoForMediaType(mediaTypes, contentType) - if !ok { - if len(contentType) != 0 || len(mediaTypes) == 0 { - return nil, nil, nil, NegotiateError{ContentType: contentType, Stream: true} - } - info = mediaTypes[0] - } - if info.StreamSerializer == nil { - return nil, nil, nil, NegotiateError{ContentType: info.MediaType, Stream: true} - } - return n.serializer.DecoderToVersion(info.Serializer, n.decode), info.StreamSerializer.Serializer, info.StreamSerializer.Framer, nil -} - -// NewClientNegotiator will attempt to retrieve the appropriate encoder, decoder, or -// stream decoder for a given content type. Does not perform any conversion, but will -// encode the object to the desired group, version, and kind. Use when creating a client. -func NewClientNegotiator(serializer NegotiatedSerializer, gv schema.GroupVersion) ClientNegotiator { - return &clientNegotiator{ - serializer: serializer, - encode: gv, - } -} - -type simpleNegotiatedSerializer struct { - info SerializerInfo -} - -func NewSimpleNegotiatedSerializer(info SerializerInfo) NegotiatedSerializer { - return &simpleNegotiatedSerializer{info: info} -} - -func (n *simpleNegotiatedSerializer) SupportedMediaTypes() []SerializerInfo { - return []SerializerInfo{n.info} -} - -func (n *simpleNegotiatedSerializer) EncoderForVersion(e Encoder, _ GroupVersioner) Encoder { - return e -} - -func (n *simpleNegotiatedSerializer) DecoderToVersion(d Decoder, _gv GroupVersioner) Decoder { - return d -} diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/register.go b/vendor/k8s.io/apimachinery/pkg/runtime/register.go deleted file mode 100644 index 1cd2e4c38..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/register.go +++ /dev/null @@ -1,31 +0,0 @@ -/* -Copyright 2015 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 runtime - -import "k8s.io/apimachinery/pkg/runtime/schema" - -// SetGroupVersionKind satisfies the ObjectKind interface for all objects that embed TypeMeta -func (obj *TypeMeta) SetGroupVersionKind(gvk schema.GroupVersionKind) { - obj.APIVersion, obj.Kind = gvk.ToAPIVersionAndKind() -} - -// GroupVersionKind satisfies the ObjectKind interface for all objects that embed TypeMeta -func (obj *TypeMeta) GroupVersionKind() schema.GroupVersionKind { - return schema.FromAPIVersionAndKind(obj.APIVersion, obj.Kind) -} - -func (obj *TypeMeta) GetObjectKind() schema.ObjectKind { return obj } diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/schema/generated.pb.go b/vendor/k8s.io/apimachinery/pkg/runtime/schema/generated.pb.go deleted file mode 100644 index 29d3ac45b..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/schema/generated.pb.go +++ /dev/null @@ -1,59 +0,0 @@ -/* -Copyright 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. -*/ - -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/runtime/schema/generated.proto - -package schema - -import ( - fmt "fmt" - - math "math" - - proto "github.com/gogo/protobuf/proto" -) - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package - -func init() { - proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/runtime/schema/generated.proto", fileDescriptor_0462724132518e0d) -} - -var fileDescriptor_0462724132518e0d = []byte{ - // 185 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0xcc, 0xaf, 0x6e, 0xc3, 0x30, - 0x10, 0xc7, 0x71, 0x9b, 0x0c, 0x0c, 0x0e, 0x0e, 0x1c, 0x1c, 0xda, 0x7c, 0x74, 0xb8, 0x2f, 0x50, - 0x5e, 0xe6, 0x24, 0x57, 0xc7, 0xb2, 0xfc, 0x47, 0x8e, 0x5d, 0xa9, 0xac, 0x8f, 0xd0, 0xc7, 0x0a, - 0x0c, 0x0c, 0x6c, 0xdc, 0x17, 0xa9, 0x64, 0x07, 0x94, 0xdd, 0x4f, 0xa7, 0xcf, 0xf7, 0xf3, 0x68, - 0xfe, 0x27, 0xa1, 0x3d, 0x9a, 0xdc, 0x51, 0x74, 0x94, 0x68, 0xc2, 0x0b, 0xb9, 0xc1, 0x47, 0xdc, - 0x1f, 0x32, 0x68, 0x2b, 0xfb, 0x51, 0x3b, 0x8a, 0x57, 0x0c, 0x46, 0x61, 0xcc, 0x2e, 0x69, 0x4b, - 0x38, 0xf5, 0x23, 0x59, 0x89, 0x8a, 0x1c, 0x45, 0x99, 0x68, 0x10, 0x21, 0xfa, 0xe4, 0xbf, 0x7e, - 0x9a, 0x13, 0xef, 0x4e, 0x04, 0xa3, 0xc4, 0xee, 0x44, 0x73, 0xdf, 0x7f, 0x4a, 0xa7, 0x31, 0x77, - 0xa2, 0xf7, 0x16, 0x95, 0x57, 0x1e, 0x2b, 0xef, 0xf2, 0xb9, 0xae, 0x3a, 0xea, 0xd5, 0xb2, 0x87, - 0xdf, 0x79, 0x03, 0xb6, 0x6c, 0xc0, 0xd6, 0x0d, 0xd8, 0xad, 0x00, 0x9f, 0x0b, 0xf0, 0xa5, 0x00, - 0x5f, 0x0b, 0xf0, 0x47, 0x01, 0x7e, 0x7f, 0x02, 0x3b, 0x7d, 0xb4, 0xf8, 0x2b, 0x00, 0x00, 0xff, - 0xff, 0xba, 0x7e, 0x65, 0xf4, 0xd6, 0x00, 0x00, 0x00, -} diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/schema/generated.proto b/vendor/k8s.io/apimachinery/pkg/runtime/schema/generated.proto deleted file mode 100644 index c50766a4b..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/schema/generated.proto +++ /dev/null @@ -1,26 +0,0 @@ -/* -Copyright 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. -*/ - - -// This file was autogenerated by go-to-protobuf. Do not edit it manually! - -syntax = "proto2"; - -package k8s.io.apimachinery.pkg.runtime.schema; - -// Package-wide variables from generator "generated". -option go_package = "schema"; - diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/schema/group_version.go b/vendor/k8s.io/apimachinery/pkg/runtime/schema/group_version.go deleted file mode 100644 index 994a3e3fa..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/schema/group_version.go +++ /dev/null @@ -1,305 +0,0 @@ -/* -Copyright 2015 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 schema - -import ( - "fmt" - "strings" -) - -// ParseResourceArg takes the common style of string which may be either `resource.group.com` or `resource.version.group.com` -// and parses it out into both possibilities. This code takes no responsibility for knowing which representation was intended -// but with a knowledge of all GroupVersions, calling code can take a very good guess. If there are only two segments, then -// `*GroupVersionResource` is nil. -// `resource.group.com` -> `group=com, version=group, resource=resource` and `group=group.com, resource=resource` -func ParseResourceArg(arg string) (*GroupVersionResource, GroupResource) { - var gvr *GroupVersionResource - if strings.Count(arg, ".") >= 2 { - s := strings.SplitN(arg, ".", 3) - gvr = &GroupVersionResource{Group: s[2], Version: s[1], Resource: s[0]} - } - - return gvr, ParseGroupResource(arg) -} - -// ParseKindArg takes the common style of string which may be either `Kind.group.com` or `Kind.version.group.com` -// and parses it out into both possibilities. This code takes no responsibility for knowing which representation was intended -// but with a knowledge of all GroupKinds, calling code can take a very good guess. If there are only two segments, then -// `*GroupVersionResource` is nil. -// `Kind.group.com` -> `group=com, version=group, kind=Kind` and `group=group.com, kind=Kind` -func ParseKindArg(arg string) (*GroupVersionKind, GroupKind) { - var gvk *GroupVersionKind - if strings.Count(arg, ".") >= 2 { - s := strings.SplitN(arg, ".", 3) - gvk = &GroupVersionKind{Group: s[2], Version: s[1], Kind: s[0]} - } - - return gvk, ParseGroupKind(arg) -} - -// GroupResource specifies a Group and a Resource, but does not force a version. This is useful for identifying -// concepts during lookup stages without having partially valid types -type GroupResource struct { - Group string - Resource string -} - -func (gr GroupResource) WithVersion(version string) GroupVersionResource { - return GroupVersionResource{Group: gr.Group, Version: version, Resource: gr.Resource} -} - -func (gr GroupResource) Empty() bool { - return len(gr.Group) == 0 && len(gr.Resource) == 0 -} - -func (gr GroupResource) String() string { - if len(gr.Group) == 0 { - return gr.Resource - } - return gr.Resource + "." + gr.Group -} - -func ParseGroupKind(gk string) GroupKind { - i := strings.Index(gk, ".") - if i == -1 { - return GroupKind{Kind: gk} - } - - return GroupKind{Group: gk[i+1:], Kind: gk[:i]} -} - -// ParseGroupResource turns "resource.group" string into a GroupResource struct. Empty strings are allowed -// for each field. -func ParseGroupResource(gr string) GroupResource { - if i := strings.Index(gr, "."); i >= 0 { - return GroupResource{Group: gr[i+1:], Resource: gr[:i]} - } - return GroupResource{Resource: gr} -} - -// GroupVersionResource unambiguously identifies a resource. It doesn't anonymously include GroupVersion -// to avoid automatic coercion. It doesn't use a GroupVersion to avoid custom marshalling -type GroupVersionResource struct { - Group string - Version string - Resource string -} - -func (gvr GroupVersionResource) Empty() bool { - return len(gvr.Group) == 0 && len(gvr.Version) == 0 && len(gvr.Resource) == 0 -} - -func (gvr GroupVersionResource) GroupResource() GroupResource { - return GroupResource{Group: gvr.Group, Resource: gvr.Resource} -} - -func (gvr GroupVersionResource) GroupVersion() GroupVersion { - return GroupVersion{Group: gvr.Group, Version: gvr.Version} -} - -func (gvr GroupVersionResource) String() string { - return strings.Join([]string{gvr.Group, "/", gvr.Version, ", Resource=", gvr.Resource}, "") -} - -// GroupKind specifies a Group and a Kind, but does not force a version. This is useful for identifying -// concepts during lookup stages without having partially valid types -type GroupKind struct { - Group string - Kind string -} - -func (gk GroupKind) Empty() bool { - return len(gk.Group) == 0 && len(gk.Kind) == 0 -} - -func (gk GroupKind) WithVersion(version string) GroupVersionKind { - return GroupVersionKind{Group: gk.Group, Version: version, Kind: gk.Kind} -} - -func (gk GroupKind) String() string { - if len(gk.Group) == 0 { - return gk.Kind - } - return gk.Kind + "." + gk.Group -} - -// GroupVersionKind unambiguously identifies a kind. It doesn't anonymously include GroupVersion -// to avoid automatic coercion. It doesn't use a GroupVersion to avoid custom marshalling -type GroupVersionKind struct { - Group string - Version string - Kind string -} - -// Empty returns true if group, version, and kind are empty -func (gvk GroupVersionKind) Empty() bool { - return len(gvk.Group) == 0 && len(gvk.Version) == 0 && len(gvk.Kind) == 0 -} - -func (gvk GroupVersionKind) GroupKind() GroupKind { - return GroupKind{Group: gvk.Group, Kind: gvk.Kind} -} - -func (gvk GroupVersionKind) GroupVersion() GroupVersion { - return GroupVersion{Group: gvk.Group, Version: gvk.Version} -} - -func (gvk GroupVersionKind) String() string { - return gvk.Group + "/" + gvk.Version + ", Kind=" + gvk.Kind -} - -// GroupVersion contains the "group" and the "version", which uniquely identifies the API. -type GroupVersion struct { - Group string - Version string -} - -// Empty returns true if group and version are empty -func (gv GroupVersion) Empty() bool { - return len(gv.Group) == 0 && len(gv.Version) == 0 -} - -// String puts "group" and "version" into a single "group/version" string. For the legacy v1 -// it returns "v1". -func (gv GroupVersion) String() string { - if len(gv.Group) > 0 { - return gv.Group + "/" + gv.Version - } - return gv.Version -} - -// Identifier implements runtime.GroupVersioner interface. -func (gv GroupVersion) Identifier() string { - return gv.String() -} - -// KindForGroupVersionKinds identifies the preferred GroupVersionKind out of a list. It returns ok false -// if none of the options match the group. It prefers a match to group and version over just group. -// TODO: Move GroupVersion to a package under pkg/runtime, since it's used by scheme. -// TODO: Introduce an adapter type between GroupVersion and runtime.GroupVersioner, and use LegacyCodec(GroupVersion) -// in fewer places. -func (gv GroupVersion) KindForGroupVersionKinds(kinds []GroupVersionKind) (target GroupVersionKind, ok bool) { - for _, gvk := range kinds { - if gvk.Group == gv.Group && gvk.Version == gv.Version { - return gvk, true - } - } - for _, gvk := range kinds { - if gvk.Group == gv.Group { - return gv.WithKind(gvk.Kind), true - } - } - return GroupVersionKind{}, false -} - -// ParseGroupVersion turns "group/version" string into a GroupVersion struct. It reports error -// if it cannot parse the string. -func ParseGroupVersion(gv string) (GroupVersion, error) { - // this can be the internal version for the legacy kube types - // TODO once we've cleared the last uses as strings, this special case should be removed. - if (len(gv) == 0) || (gv == "/") { - return GroupVersion{}, nil - } - - switch strings.Count(gv, "/") { - case 0: - return GroupVersion{"", gv}, nil - case 1: - i := strings.Index(gv, "/") - return GroupVersion{gv[:i], gv[i+1:]}, nil - default: - return GroupVersion{}, fmt.Errorf("unexpected GroupVersion string: %v", gv) - } -} - -// WithKind creates a GroupVersionKind based on the method receiver's GroupVersion and the passed Kind. -func (gv GroupVersion) WithKind(kind string) GroupVersionKind { - return GroupVersionKind{Group: gv.Group, Version: gv.Version, Kind: kind} -} - -// WithResource creates a GroupVersionResource based on the method receiver's GroupVersion and the passed Resource. -func (gv GroupVersion) WithResource(resource string) GroupVersionResource { - return GroupVersionResource{Group: gv.Group, Version: gv.Version, Resource: resource} -} - -// GroupVersions can be used to represent a set of desired group versions. -// TODO: Move GroupVersions to a package under pkg/runtime, since it's used by scheme. -// TODO: Introduce an adapter type between GroupVersions and runtime.GroupVersioner, and use LegacyCodec(GroupVersion) -// in fewer places. -type GroupVersions []GroupVersion - -// Identifier implements runtime.GroupVersioner interface. -func (gvs GroupVersions) Identifier() string { - groupVersions := make([]string, 0, len(gvs)) - for i := range gvs { - groupVersions = append(groupVersions, gvs[i].String()) - } - return fmt.Sprintf("[%s]", strings.Join(groupVersions, ",")) -} - -// KindForGroupVersionKinds identifies the preferred GroupVersionKind out of a list. It returns ok false -// if none of the options match the group. -func (gvs GroupVersions) KindForGroupVersionKinds(kinds []GroupVersionKind) (GroupVersionKind, bool) { - var targets []GroupVersionKind - for _, gv := range gvs { - target, ok := gv.KindForGroupVersionKinds(kinds) - if !ok { - continue - } - targets = append(targets, target) - } - if len(targets) == 1 { - return targets[0], true - } - if len(targets) > 1 { - return bestMatch(kinds, targets), true - } - return GroupVersionKind{}, false -} - -// bestMatch tries to pick best matching GroupVersionKind and falls back to the first -// found if no exact match exists. -func bestMatch(kinds []GroupVersionKind, targets []GroupVersionKind) GroupVersionKind { - for _, gvk := range targets { - for _, k := range kinds { - if k == gvk { - return k - } - } - } - return targets[0] -} - -// ToAPIVersionAndKind is a convenience method for satisfying runtime.Object on types that -// do not use TypeMeta. -func (gvk GroupVersionKind) ToAPIVersionAndKind() (string, string) { - if gvk.Empty() { - return "", "" - } - return gvk.GroupVersion().String(), gvk.Kind -} - -// FromAPIVersionAndKind returns a GVK representing the provided fields for types that -// do not use TypeMeta. This method exists to support test types and legacy serializations -// that have a distinct group and kind. -// TODO: further reduce usage of this method. -func FromAPIVersionAndKind(apiVersion, kind string) GroupVersionKind { - if gv, err := ParseGroupVersion(apiVersion); err == nil { - return GroupVersionKind{Group: gv.Group, Version: gv.Version, Kind: kind} - } - return GroupVersionKind{Kind: kind} -} diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/schema/interfaces.go b/vendor/k8s.io/apimachinery/pkg/runtime/schema/interfaces.go deleted file mode 100644 index f04453fb0..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/schema/interfaces.go +++ /dev/null @@ -1,40 +0,0 @@ -/* -Copyright 2016 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 schema - -// All objects that are serialized from a Scheme encode their type information. This interface is used -// by serialization to set type information from the Scheme onto the serialized version of an object. -// For objects that cannot be serialized or have unique requirements, this interface may be a no-op. -type ObjectKind interface { - // SetGroupVersionKind sets or clears the intended serialized kind of an object. Passing kind nil - // should clear the current setting. - SetGroupVersionKind(kind GroupVersionKind) - // GroupVersionKind returns the stored group, version, and kind of an object, or an empty struct - // if the object does not expose or provide these fields. - GroupVersionKind() GroupVersionKind -} - -// EmptyObjectKind implements the ObjectKind interface as a noop -var EmptyObjectKind = emptyObjectKind{} - -type emptyObjectKind struct{} - -// SetGroupVersionKind implements the ObjectKind interface -func (emptyObjectKind) SetGroupVersionKind(gvk GroupVersionKind) {} - -// GroupVersionKind implements the ObjectKind interface -func (emptyObjectKind) GroupVersionKind() GroupVersionKind { return GroupVersionKind{} } diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/scheme.go b/vendor/k8s.io/apimachinery/pkg/runtime/scheme.go deleted file mode 100644 index ae47ab3ab..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/scheme.go +++ /dev/null @@ -1,728 +0,0 @@ -/* -Copyright 2014 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 runtime - -import ( - "fmt" - "reflect" - "strings" - - "k8s.io/apimachinery/pkg/conversion" - "k8s.io/apimachinery/pkg/runtime/schema" - "k8s.io/apimachinery/pkg/util/naming" - utilruntime "k8s.io/apimachinery/pkg/util/runtime" - "k8s.io/apimachinery/pkg/util/sets" -) - -// Scheme defines methods for serializing and deserializing API objects, a type -// registry for converting group, version, and kind information to and from Go -// schemas, and mappings between Go schemas of different versions. A scheme is the -// foundation for a versioned API and versioned configuration over time. -// -// In a Scheme, a Type is a particular Go struct, a Version is a point-in-time -// identifier for a particular representation of that Type (typically backwards -// compatible), a Kind is the unique name for that Type within the Version, and a -// Group identifies a set of Versions, Kinds, and Types that evolve over time. An -// Unversioned Type is one that is not yet formally bound to a type and is promised -// to be backwards compatible (effectively a "v1" of a Type that does not expect -// to break in the future). -// -// Schemes are not expected to change at runtime and are only threadsafe after -// registration is complete. -type Scheme struct { - // versionMap allows one to figure out the go type of an object with - // the given version and name. - gvkToType map[schema.GroupVersionKind]reflect.Type - - // typeToGroupVersion allows one to find metadata for a given go object. - // The reflect.Type we index by should *not* be a pointer. - typeToGVK map[reflect.Type][]schema.GroupVersionKind - - // unversionedTypes are transformed without conversion in ConvertToVersion. - unversionedTypes map[reflect.Type]schema.GroupVersionKind - - // unversionedKinds are the names of kinds that can be created in the context of any group - // or version - // TODO: resolve the status of unversioned types. - unversionedKinds map[string]reflect.Type - - // Map from version and resource to the corresponding func to convert - // resource field labels in that version to internal version. - fieldLabelConversionFuncs map[schema.GroupVersionKind]FieldLabelConversionFunc - - // defaulterFuncs is an array of interfaces to be called with an object to provide defaulting - // the provided object must be a pointer. - defaulterFuncs map[reflect.Type]func(interface{}) - - // converter stores all registered conversion functions. It also has - // default converting behavior. - converter *conversion.Converter - - // versionPriority is a map of groups to ordered lists of versions for those groups indicating the - // default priorities of these versions as registered in the scheme - versionPriority map[string][]string - - // observedVersions keeps track of the order we've seen versions during type registration - observedVersions []schema.GroupVersion - - // schemeName is the name of this scheme. If you don't specify a name, the stack of the NewScheme caller will be used. - // This is useful for error reporting to indicate the origin of the scheme. - schemeName string -} - -// FieldLabelConversionFunc converts a field selector to internal representation. -type FieldLabelConversionFunc func(label, value string) (internalLabel, internalValue string, err error) - -// NewScheme creates a new Scheme. This scheme is pluggable by default. -func NewScheme() *Scheme { - s := &Scheme{ - gvkToType: map[schema.GroupVersionKind]reflect.Type{}, - typeToGVK: map[reflect.Type][]schema.GroupVersionKind{}, - unversionedTypes: map[reflect.Type]schema.GroupVersionKind{}, - unversionedKinds: map[string]reflect.Type{}, - fieldLabelConversionFuncs: map[schema.GroupVersionKind]FieldLabelConversionFunc{}, - defaulterFuncs: map[reflect.Type]func(interface{}){}, - versionPriority: map[string][]string{}, - schemeName: naming.GetNameFromCallsite(internalPackages...), - } - s.converter = conversion.NewConverter(s.nameFunc) - - // Enable couple default conversions by default. - utilruntime.Must(RegisterEmbeddedConversions(s)) - utilruntime.Must(RegisterStringConversions(s)) - return s -} - -// nameFunc returns the name of the type that we wish to use to determine when two types attempt -// a conversion. Defaults to the go name of the type if the type is not registered. -func (s *Scheme) nameFunc(t reflect.Type) string { - // find the preferred names for this type - gvks, ok := s.typeToGVK[t] - if !ok { - return t.Name() - } - - for _, gvk := range gvks { - internalGV := gvk.GroupVersion() - internalGV.Version = APIVersionInternal // this is hacky and maybe should be passed in - internalGVK := internalGV.WithKind(gvk.Kind) - - if internalType, exists := s.gvkToType[internalGVK]; exists { - return s.typeToGVK[internalType][0].Kind - } - } - - return gvks[0].Kind -} - -// Converter allows access to the converter for the scheme -func (s *Scheme) Converter() *conversion.Converter { - return s.converter -} - -// AddUnversionedTypes registers the provided types as "unversioned", which means that they follow special rules. -// Whenever an object of this type is serialized, it is serialized with the provided group version and is not -// converted. Thus unversioned objects are expected to remain backwards compatible forever, as if they were in an -// API group and version that would never be updated. -// -// TODO: there is discussion about removing unversioned and replacing it with objects that are manifest into -// every version with particular schemas. Resolve this method at that point. -func (s *Scheme) AddUnversionedTypes(version schema.GroupVersion, types ...Object) { - s.addObservedVersion(version) - s.AddKnownTypes(version, types...) - for _, obj := range types { - t := reflect.TypeOf(obj).Elem() - gvk := version.WithKind(t.Name()) - s.unversionedTypes[t] = gvk - if old, ok := s.unversionedKinds[gvk.Kind]; ok && t != old { - panic(fmt.Sprintf("%v.%v has already been registered as unversioned kind %q - kind name must be unique in scheme %q", old.PkgPath(), old.Name(), gvk, s.schemeName)) - } - s.unversionedKinds[gvk.Kind] = t - } -} - -// AddKnownTypes registers all types passed in 'types' as being members of version 'version'. -// All objects passed to types should be pointers to structs. The name that go reports for -// the struct becomes the "kind" field when encoding. Version may not be empty - use the -// APIVersionInternal constant if you have a type that does not have a formal version. -func (s *Scheme) AddKnownTypes(gv schema.GroupVersion, types ...Object) { - s.addObservedVersion(gv) - for _, obj := range types { - t := reflect.TypeOf(obj) - if t.Kind() != reflect.Ptr { - panic("All types must be pointers to structs.") - } - t = t.Elem() - s.AddKnownTypeWithName(gv.WithKind(t.Name()), obj) - } -} - -// AddKnownTypeWithName is like AddKnownTypes, but it lets you specify what this type should -// be encoded as. Useful for testing when you don't want to make multiple packages to define -// your structs. Version may not be empty - use the APIVersionInternal constant if you have a -// type that does not have a formal version. -func (s *Scheme) AddKnownTypeWithName(gvk schema.GroupVersionKind, obj Object) { - s.addObservedVersion(gvk.GroupVersion()) - t := reflect.TypeOf(obj) - if len(gvk.Version) == 0 { - panic(fmt.Sprintf("version is required on all types: %s %v", gvk, t)) - } - if t.Kind() != reflect.Ptr { - panic("All types must be pointers to structs.") - } - t = t.Elem() - if t.Kind() != reflect.Struct { - panic("All types must be pointers to structs.") - } - - if oldT, found := s.gvkToType[gvk]; found && oldT != t { - panic(fmt.Sprintf("Double registration of different types for %v: old=%v.%v, new=%v.%v in scheme %q", gvk, oldT.PkgPath(), oldT.Name(), t.PkgPath(), t.Name(), s.schemeName)) - } - - s.gvkToType[gvk] = t - - for _, existingGvk := range s.typeToGVK[t] { - if existingGvk == gvk { - return - } - } - s.typeToGVK[t] = append(s.typeToGVK[t], gvk) - - // if the type implements DeepCopyInto(<obj>), register a self-conversion - if m := reflect.ValueOf(obj).MethodByName("DeepCopyInto"); m.IsValid() && m.Type().NumIn() == 1 && m.Type().NumOut() == 0 && m.Type().In(0) == reflect.TypeOf(obj) { - if err := s.AddGeneratedConversionFunc(obj, obj, func(a, b interface{}, scope conversion.Scope) error { - // copy a to b - reflect.ValueOf(a).MethodByName("DeepCopyInto").Call([]reflect.Value{reflect.ValueOf(b)}) - // clear TypeMeta to match legacy reflective conversion - b.(Object).GetObjectKind().SetGroupVersionKind(schema.GroupVersionKind{}) - return nil - }); err != nil { - panic(err) - } - } -} - -// KnownTypes returns the types known for the given version. -func (s *Scheme) KnownTypes(gv schema.GroupVersion) map[string]reflect.Type { - types := make(map[string]reflect.Type) - for gvk, t := range s.gvkToType { - if gv != gvk.GroupVersion() { - continue - } - - types[gvk.Kind] = t - } - return types -} - -// VersionsForGroupKind returns the versions that a particular GroupKind can be converted to within the given group. -// A GroupKind might be converted to a different group. That information is available in EquivalentResourceMapper. -func (s *Scheme) VersionsForGroupKind(gk schema.GroupKind) []schema.GroupVersion { - availableVersions := []schema.GroupVersion{} - for gvk := range s.gvkToType { - if gk != gvk.GroupKind() { - continue - } - - availableVersions = append(availableVersions, gvk.GroupVersion()) - } - - // order the return for stability - ret := []schema.GroupVersion{} - for _, version := range s.PrioritizedVersionsForGroup(gk.Group) { - for _, availableVersion := range availableVersions { - if version != availableVersion { - continue - } - ret = append(ret, availableVersion) - } - } - - return ret -} - -// AllKnownTypes returns the all known types. -func (s *Scheme) AllKnownTypes() map[schema.GroupVersionKind]reflect.Type { - return s.gvkToType -} - -// ObjectKinds returns all possible group,version,kind of the go object, true if the -// object is considered unversioned, or an error if it's not a pointer or is unregistered. -func (s *Scheme) ObjectKinds(obj Object) ([]schema.GroupVersionKind, bool, error) { - // Unstructured objects are always considered to have their declared GVK - if _, ok := obj.(Unstructured); ok { - // we require that the GVK be populated in order to recognize the object - gvk := obj.GetObjectKind().GroupVersionKind() - if len(gvk.Kind) == 0 { - return nil, false, NewMissingKindErr("unstructured object has no kind") - } - if len(gvk.Version) == 0 { - return nil, false, NewMissingVersionErr("unstructured object has no version") - } - return []schema.GroupVersionKind{gvk}, false, nil - } - - v, err := conversion.EnforcePtr(obj) - if err != nil { - return nil, false, err - } - t := v.Type() - - gvks, ok := s.typeToGVK[t] - if !ok { - return nil, false, NewNotRegisteredErrForType(s.schemeName, t) - } - _, unversionedType := s.unversionedTypes[t] - - return gvks, unversionedType, nil -} - -// Recognizes returns true if the scheme is able to handle the provided group,version,kind -// of an object. -func (s *Scheme) Recognizes(gvk schema.GroupVersionKind) bool { - _, exists := s.gvkToType[gvk] - return exists -} - -func (s *Scheme) IsUnversioned(obj Object) (bool, bool) { - v, err := conversion.EnforcePtr(obj) - if err != nil { - return false, false - } - t := v.Type() - - if _, ok := s.typeToGVK[t]; !ok { - return false, false - } - _, ok := s.unversionedTypes[t] - return ok, true -} - -// New returns a new API object of the given version and name, or an error if it hasn't -// been registered. The version and kind fields must be specified. -func (s *Scheme) New(kind schema.GroupVersionKind) (Object, error) { - if t, exists := s.gvkToType[kind]; exists { - return reflect.New(t).Interface().(Object), nil - } - - if t, exists := s.unversionedKinds[kind.Kind]; exists { - return reflect.New(t).Interface().(Object), nil - } - return nil, NewNotRegisteredErrForKind(s.schemeName, kind) -} - -// AddIgnoredConversionType identifies a pair of types that should be skipped by -// conversion (because the data inside them is explicitly dropped during -// conversion). -func (s *Scheme) AddIgnoredConversionType(from, to interface{}) error { - return s.converter.RegisterIgnoredConversion(from, to) -} - -// AddConversionFunc registers a function that converts between a and b by passing objects of those -// types to the provided function. The function *must* accept objects of a and b - this machinery will not enforce -// any other guarantee. -func (s *Scheme) AddConversionFunc(a, b interface{}, fn conversion.ConversionFunc) error { - return s.converter.RegisterUntypedConversionFunc(a, b, fn) -} - -// AddGeneratedConversionFunc registers a function that converts between a and b by passing objects of those -// types to the provided function. The function *must* accept objects of a and b - this machinery will not enforce -// any other guarantee. -func (s *Scheme) AddGeneratedConversionFunc(a, b interface{}, fn conversion.ConversionFunc) error { - return s.converter.RegisterGeneratedUntypedConversionFunc(a, b, fn) -} - -// AddFieldLabelConversionFunc adds a conversion function to convert field selectors -// of the given kind from the given version to internal version representation. -func (s *Scheme) AddFieldLabelConversionFunc(gvk schema.GroupVersionKind, conversionFunc FieldLabelConversionFunc) error { - s.fieldLabelConversionFuncs[gvk] = conversionFunc - return nil -} - -// AddTypeDefaultingFunc registers a function that is passed a pointer to an -// object and can default fields on the object. These functions will be invoked -// when Default() is called. The function will never be called unless the -// defaulted object matches srcType. If this function is invoked twice with the -// same srcType, the fn passed to the later call will be used instead. -func (s *Scheme) AddTypeDefaultingFunc(srcType Object, fn func(interface{})) { - s.defaulterFuncs[reflect.TypeOf(srcType)] = fn -} - -// Default sets defaults on the provided Object. -func (s *Scheme) Default(src Object) { - if fn, ok := s.defaulterFuncs[reflect.TypeOf(src)]; ok { - fn(src) - } -} - -// Convert will attempt to convert in into out. Both must be pointers. For easy -// testing of conversion functions. Returns an error if the conversion isn't -// possible. You can call this with types that haven't been registered (for example, -// a to test conversion of types that are nested within registered types). The -// context interface is passed to the convertor. Convert also supports Unstructured -// types and will convert them intelligently. -func (s *Scheme) Convert(in, out interface{}, context interface{}) error { - unstructuredIn, okIn := in.(Unstructured) - unstructuredOut, okOut := out.(Unstructured) - switch { - case okIn && okOut: - // converting unstructured input to an unstructured output is a straight copy - unstructured - // is a "smart holder" and the contents are passed by reference between the two objects - unstructuredOut.SetUnstructuredContent(unstructuredIn.UnstructuredContent()) - return nil - - case okOut: - // if the output is an unstructured object, use the standard Go type to unstructured - // conversion. The object must not be internal. - obj, ok := in.(Object) - if !ok { - return fmt.Errorf("unable to convert object type %T to Unstructured, must be a runtime.Object", in) - } - gvks, unversioned, err := s.ObjectKinds(obj) - if err != nil { - return err - } - gvk := gvks[0] - - // if no conversion is necessary, convert immediately - if unversioned || gvk.Version != APIVersionInternal { - content, err := DefaultUnstructuredConverter.ToUnstructured(in) - if err != nil { - return err - } - unstructuredOut.SetUnstructuredContent(content) - unstructuredOut.GetObjectKind().SetGroupVersionKind(gvk) - return nil - } - - // attempt to convert the object to an external version first. - target, ok := context.(GroupVersioner) - if !ok { - return fmt.Errorf("unable to convert the internal object type %T to Unstructured without providing a preferred version to convert to", in) - } - // Convert is implicitly unsafe, so we don't need to perform a safe conversion - versioned, err := s.UnsafeConvertToVersion(obj, target) - if err != nil { - return err - } - content, err := DefaultUnstructuredConverter.ToUnstructured(versioned) - if err != nil { - return err - } - unstructuredOut.SetUnstructuredContent(content) - return nil - - case okIn: - // converting an unstructured object to any type is modeled by first converting - // the input to a versioned type, then running standard conversions - typed, err := s.unstructuredToTyped(unstructuredIn) - if err != nil { - return err - } - in = typed - } - - meta := s.generateConvertMeta(in) - meta.Context = context - return s.converter.Convert(in, out, meta) -} - -// ConvertFieldLabel alters the given field label and value for an kind field selector from -// versioned representation to an unversioned one or returns an error. -func (s *Scheme) ConvertFieldLabel(gvk schema.GroupVersionKind, label, value string) (string, string, error) { - conversionFunc, ok := s.fieldLabelConversionFuncs[gvk] - if !ok { - return DefaultMetaV1FieldSelectorConversion(label, value) - } - return conversionFunc(label, value) -} - -// ConvertToVersion attempts to convert an input object to its matching Kind in another -// version within this scheme. Will return an error if the provided version does not -// contain the inKind (or a mapping by name defined with AddKnownTypeWithName). Will also -// return an error if the conversion does not result in a valid Object being -// returned. Passes target down to the conversion methods as the Context on the scope. -func (s *Scheme) ConvertToVersion(in Object, target GroupVersioner) (Object, error) { - return s.convertToVersion(true, in, target) -} - -// UnsafeConvertToVersion will convert in to the provided target if such a conversion is possible, -// but does not guarantee the output object does not share fields with the input object. It attempts to be as -// efficient as possible when doing conversion. -func (s *Scheme) UnsafeConvertToVersion(in Object, target GroupVersioner) (Object, error) { - return s.convertToVersion(false, in, target) -} - -// convertToVersion handles conversion with an optional copy. -func (s *Scheme) convertToVersion(copy bool, in Object, target GroupVersioner) (Object, error) { - var t reflect.Type - - if u, ok := in.(Unstructured); ok { - typed, err := s.unstructuredToTyped(u) - if err != nil { - return nil, err - } - - in = typed - // unstructuredToTyped returns an Object, which must be a pointer to a struct. - t = reflect.TypeOf(in).Elem() - - } else { - // determine the incoming kinds with as few allocations as possible. - t = reflect.TypeOf(in) - if t.Kind() != reflect.Ptr { - return nil, fmt.Errorf("only pointer types may be converted: %v", t) - } - t = t.Elem() - if t.Kind() != reflect.Struct { - return nil, fmt.Errorf("only pointers to struct types may be converted: %v", t) - } - } - - kinds, ok := s.typeToGVK[t] - if !ok || len(kinds) == 0 { - return nil, NewNotRegisteredErrForType(s.schemeName, t) - } - - gvk, ok := target.KindForGroupVersionKinds(kinds) - if !ok { - // try to see if this type is listed as unversioned (for legacy support) - // TODO: when we move to server API versions, we should completely remove the unversioned concept - if unversionedKind, ok := s.unversionedTypes[t]; ok { - if gvk, ok := target.KindForGroupVersionKinds([]schema.GroupVersionKind{unversionedKind}); ok { - return copyAndSetTargetKind(copy, in, gvk) - } - return copyAndSetTargetKind(copy, in, unversionedKind) - } - return nil, NewNotRegisteredErrForTarget(s.schemeName, t, target) - } - - // target wants to use the existing type, set kind and return (no conversion necessary) - for _, kind := range kinds { - if gvk == kind { - return copyAndSetTargetKind(copy, in, gvk) - } - } - - // type is unversioned, no conversion necessary - if unversionedKind, ok := s.unversionedTypes[t]; ok { - if gvk, ok := target.KindForGroupVersionKinds([]schema.GroupVersionKind{unversionedKind}); ok { - return copyAndSetTargetKind(copy, in, gvk) - } - return copyAndSetTargetKind(copy, in, unversionedKind) - } - - out, err := s.New(gvk) - if err != nil { - return nil, err - } - - if copy { - in = in.DeepCopyObject() - } - - meta := s.generateConvertMeta(in) - meta.Context = target - if err := s.converter.Convert(in, out, meta); err != nil { - return nil, err - } - - setTargetKind(out, gvk) - return out, nil -} - -// unstructuredToTyped attempts to transform an unstructured object to a typed -// object if possible. It will return an error if conversion is not possible, or the versioned -// Go form of the object. Note that this conversion will lose fields. -func (s *Scheme) unstructuredToTyped(in Unstructured) (Object, error) { - // the type must be something we recognize - gvks, _, err := s.ObjectKinds(in) - if err != nil { - return nil, err - } - typed, err := s.New(gvks[0]) - if err != nil { - return nil, err - } - if err := DefaultUnstructuredConverter.FromUnstructured(in.UnstructuredContent(), typed); err != nil { - return nil, fmt.Errorf("unable to convert unstructured object to %v: %v", gvks[0], err) - } - return typed, nil -} - -// generateConvertMeta constructs the meta value we pass to Convert. -func (s *Scheme) generateConvertMeta(in interface{}) *conversion.Meta { - return s.converter.DefaultMeta(reflect.TypeOf(in)) -} - -// copyAndSetTargetKind performs a conditional copy before returning the object, or an error if copy was not successful. -func copyAndSetTargetKind(copy bool, obj Object, kind schema.GroupVersionKind) (Object, error) { - if copy { - obj = obj.DeepCopyObject() - } - setTargetKind(obj, kind) - return obj, nil -} - -// setTargetKind sets the kind on an object, taking into account whether the target kind is the internal version. -func setTargetKind(obj Object, kind schema.GroupVersionKind) { - if kind.Version == APIVersionInternal { - // internal is a special case - // TODO: look at removing the need to special case this - obj.GetObjectKind().SetGroupVersionKind(schema.GroupVersionKind{}) - return - } - obj.GetObjectKind().SetGroupVersionKind(kind) -} - -// SetVersionPriority allows specifying a precise order of priority. All specified versions must be in the same group, -// and the specified order overwrites any previously specified order for this group -func (s *Scheme) SetVersionPriority(versions ...schema.GroupVersion) error { - groups := sets.String{} - order := []string{} - for _, version := range versions { - if len(version.Version) == 0 || version.Version == APIVersionInternal { - return fmt.Errorf("internal versions cannot be prioritized: %v", version) - } - - groups.Insert(version.Group) - order = append(order, version.Version) - } - if len(groups) != 1 { - return fmt.Errorf("must register versions for exactly one group: %v", strings.Join(groups.List(), ", ")) - } - - s.versionPriority[groups.List()[0]] = order - return nil -} - -// PrioritizedVersionsForGroup returns versions for a single group in priority order -func (s *Scheme) PrioritizedVersionsForGroup(group string) []schema.GroupVersion { - ret := []schema.GroupVersion{} - for _, version := range s.versionPriority[group] { - ret = append(ret, schema.GroupVersion{Group: group, Version: version}) - } - for _, observedVersion := range s.observedVersions { - if observedVersion.Group != group { - continue - } - found := false - for _, existing := range ret { - if existing == observedVersion { - found = true - break - } - } - if !found { - ret = append(ret, observedVersion) - } - } - - return ret -} - -// PrioritizedVersionsAllGroups returns all known versions in their priority order. Groups are random, but -// versions for a single group are prioritized -func (s *Scheme) PrioritizedVersionsAllGroups() []schema.GroupVersion { - ret := []schema.GroupVersion{} - for group, versions := range s.versionPriority { - for _, version := range versions { - ret = append(ret, schema.GroupVersion{Group: group, Version: version}) - } - } - for _, observedVersion := range s.observedVersions { - found := false - for _, existing := range ret { - if existing == observedVersion { - found = true - break - } - } - if !found { - ret = append(ret, observedVersion) - } - } - return ret -} - -// PreferredVersionAllGroups returns the most preferred version for every group. -// group ordering is random. -func (s *Scheme) PreferredVersionAllGroups() []schema.GroupVersion { - ret := []schema.GroupVersion{} - for group, versions := range s.versionPriority { - for _, version := range versions { - ret = append(ret, schema.GroupVersion{Group: group, Version: version}) - break - } - } - for _, observedVersion := range s.observedVersions { - found := false - for _, existing := range ret { - if existing.Group == observedVersion.Group { - found = true - break - } - } - if !found { - ret = append(ret, observedVersion) - } - } - - return ret -} - -// IsGroupRegistered returns true if types for the group have been registered with the scheme -func (s *Scheme) IsGroupRegistered(group string) bool { - for _, observedVersion := range s.observedVersions { - if observedVersion.Group == group { - return true - } - } - return false -} - -// IsVersionRegistered returns true if types for the version have been registered with the scheme -func (s *Scheme) IsVersionRegistered(version schema.GroupVersion) bool { - for _, observedVersion := range s.observedVersions { - if observedVersion == version { - return true - } - } - - return false -} - -func (s *Scheme) addObservedVersion(version schema.GroupVersion) { - if len(version.Version) == 0 || version.Version == APIVersionInternal { - return - } - for _, observedVersion := range s.observedVersions { - if observedVersion == version { - return - } - } - - s.observedVersions = append(s.observedVersions, version) -} - -func (s *Scheme) Name() string { - return s.schemeName -} - -// internalPackages are packages that ignored when creating a default reflector name. These packages are in the common -// call chains to NewReflector, so they'd be low entropy names for reflectors -var internalPackages = []string{"k8s.io/apimachinery/pkg/runtime/scheme.go"} diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/scheme_builder.go b/vendor/k8s.io/apimachinery/pkg/runtime/scheme_builder.go deleted file mode 100644 index 944db4818..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/scheme_builder.go +++ /dev/null @@ -1,48 +0,0 @@ -/* -Copyright 2015 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 runtime - -// SchemeBuilder collects functions that add things to a scheme. It's to allow -// code to compile without explicitly referencing generated types. You should -// declare one in each package that will have generated deep copy or conversion -// functions. -type SchemeBuilder []func(*Scheme) error - -// AddToScheme applies all the stored functions to the scheme. A non-nil error -// indicates that one function failed and the attempt was abandoned. -func (sb *SchemeBuilder) AddToScheme(s *Scheme) error { - for _, f := range *sb { - if err := f(s); err != nil { - return err - } - } - return nil -} - -// Register adds a scheme setup function to the list. -func (sb *SchemeBuilder) Register(funcs ...func(*Scheme) error) { - for _, f := range funcs { - *sb = append(*sb, f) - } -} - -// NewSchemeBuilder calls Register for you. -func NewSchemeBuilder(funcs ...func(*Scheme) error) SchemeBuilder { - var sb SchemeBuilder - sb.Register(funcs...) - return sb -} diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/swagger_doc_generator.go b/vendor/k8s.io/apimachinery/pkg/runtime/swagger_doc_generator.go deleted file mode 100644 index 5bc642bc8..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/swagger_doc_generator.go +++ /dev/null @@ -1,262 +0,0 @@ -/* -Copyright 2015 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 runtime - -import ( - "bytes" - "fmt" - "go/ast" - "go/doc" - "go/parser" - "go/token" - "io" - "reflect" - "strings" -) - -// Pair of strings. We keed the name of fields and the doc -type Pair struct { - Name, Doc string -} - -// KubeTypes is an array to represent all available types in a parsed file. [0] is for the type itself -type KubeTypes []Pair - -func astFrom(filePath string) *doc.Package { - fset := token.NewFileSet() - m := make(map[string]*ast.File) - - f, err := parser.ParseFile(fset, filePath, nil, parser.ParseComments) - if err != nil { - fmt.Println(err) - return nil - } - - m[filePath] = f - apkg, _ := ast.NewPackage(fset, m, nil, nil) - - return doc.New(apkg, "", 0) -} - -func fmtRawDoc(rawDoc string) string { - var buffer bytes.Buffer - delPrevChar := func() { - if buffer.Len() > 0 { - buffer.Truncate(buffer.Len() - 1) // Delete the last " " or "\n" - } - } - - // Ignore all lines after --- - rawDoc = strings.Split(rawDoc, "---")[0] - - for _, line := range strings.Split(rawDoc, "\n") { - line = strings.TrimRight(line, " ") - leading := strings.TrimLeft(line, " ") - switch { - case len(line) == 0: // Keep paragraphs - delPrevChar() - buffer.WriteString("\n\n") - case strings.HasPrefix(leading, "TODO"): // Ignore one line TODOs - case strings.HasPrefix(leading, "+"): // Ignore instructions to the generators - default: - if strings.HasPrefix(line, " ") || strings.HasPrefix(line, "\t") { - delPrevChar() - line = "\n" + line + "\n" // Replace it with newline. This is useful when we have a line with: "Example:\n\tJSON-someting..." - } else { - line += " " - } - buffer.WriteString(line) - } - } - - postDoc := strings.TrimRight(buffer.String(), "\n") - postDoc = strings.Replace(postDoc, "\\\"", "\"", -1) // replace user's \" to " - postDoc = strings.Replace(postDoc, "\"", "\\\"", -1) // Escape " - postDoc = strings.Replace(postDoc, "\n", "\\n", -1) - postDoc = strings.Replace(postDoc, "\t", "\\t", -1) - - return postDoc -} - -// fieldName returns the name of the field as it should appear in JSON format -// "-" indicates that this field is not part of the JSON representation -func fieldName(field *ast.Field) string { - jsonTag := "" - if field.Tag != nil { - jsonTag = reflect.StructTag(field.Tag.Value[1 : len(field.Tag.Value)-1]).Get("json") // Delete first and last quotation - if strings.Contains(jsonTag, "inline") { - return "-" - } - } - - jsonTag = strings.Split(jsonTag, ",")[0] // This can return "-" - if jsonTag == "" { - if field.Names != nil { - return field.Names[0].Name - } - return field.Type.(*ast.Ident).Name - } - return jsonTag -} - -// A buffer of lines that will be written. -type bufferedLine struct { - line string - indentation int -} - -type buffer struct { - lines []bufferedLine -} - -func newBuffer() *buffer { - return &buffer{ - lines: make([]bufferedLine, 0), - } -} - -func (b *buffer) addLine(line string, indent int) { - b.lines = append(b.lines, bufferedLine{line, indent}) -} - -func (b *buffer) flushLines(w io.Writer) error { - for _, line := range b.lines { - indentation := strings.Repeat("\t", line.indentation) - fullLine := fmt.Sprintf("%s%s", indentation, line.line) - if _, err := io.WriteString(w, fullLine); err != nil { - return err - } - } - return nil -} - -func writeFuncHeader(b *buffer, structName string, indent int) { - s := fmt.Sprintf("var map_%s = map[string]string {\n", structName) - b.addLine(s, indent) -} - -func writeFuncFooter(b *buffer, structName string, indent int) { - b.addLine("}\n", indent) // Closes the map definition - - s := fmt.Sprintf("func (%s) SwaggerDoc() map[string]string {\n", structName) - b.addLine(s, indent) - s = fmt.Sprintf("return map_%s\n", structName) - b.addLine(s, indent+1) - b.addLine("}\n", indent) // Closes the function definition -} - -func writeMapBody(b *buffer, kubeType []Pair, indent int) { - format := "\"%s\": \"%s\",\n" - for _, pair := range kubeType { - s := fmt.Sprintf(format, pair.Name, pair.Doc) - b.addLine(s, indent+2) - } -} - -// ParseDocumentationFrom gets all types' documentation and returns them as an -// array. Each type is again represented as an array (we have to use arrays as we -// need to be sure for the order of the fields). This function returns fields and -// struct definitions that have no documentation as {name, ""}. -func ParseDocumentationFrom(src string) []KubeTypes { - var docForTypes []KubeTypes - - pkg := astFrom(src) - - for _, kubType := range pkg.Types { - if structType, ok := kubType.Decl.Specs[0].(*ast.TypeSpec).Type.(*ast.StructType); ok { - var ks KubeTypes - ks = append(ks, Pair{kubType.Name, fmtRawDoc(kubType.Doc)}) - - for _, field := range structType.Fields.List { - if n := fieldName(field); n != "-" { - fieldDoc := fmtRawDoc(field.Doc.Text()) - ks = append(ks, Pair{n, fieldDoc}) - } - } - docForTypes = append(docForTypes, ks) - } - } - - return docForTypes -} - -// WriteSwaggerDocFunc writes a declaration of a function as a string. This function is used in -// Swagger as a documentation source for structs and theirs fields -func WriteSwaggerDocFunc(kubeTypes []KubeTypes, w io.Writer) error { - for _, kubeType := range kubeTypes { - structName := kubeType[0].Name - kubeType[0].Name = "" - - // Ignore empty documentation - docfulTypes := make(KubeTypes, 0, len(kubeType)) - for _, pair := range kubeType { - if pair.Doc != "" { - docfulTypes = append(docfulTypes, pair) - } - } - - if len(docfulTypes) == 0 { - continue // If no fields and the struct have documentation, skip the function definition - } - - indent := 0 - buffer := newBuffer() - - writeFuncHeader(buffer, structName, indent) - writeMapBody(buffer, docfulTypes, indent) - writeFuncFooter(buffer, structName, indent) - buffer.addLine("\n", 0) - - if err := buffer.flushLines(w); err != nil { - return err - } - } - - return nil -} - -// VerifySwaggerDocsExist writes in a io.Writer a list of structs and fields that -// are missing of documentation. -func VerifySwaggerDocsExist(kubeTypes []KubeTypes, w io.Writer) (int, error) { - missingDocs := 0 - buffer := newBuffer() - - for _, kubeType := range kubeTypes { - structName := kubeType[0].Name - if kubeType[0].Doc == "" { - format := "Missing documentation for the struct itself: %s\n" - s := fmt.Sprintf(format, structName) - buffer.addLine(s, 0) - missingDocs++ - } - kubeType = kubeType[1:] // Skip struct definition - - for _, pair := range kubeType { // Iterate only the fields - if pair.Doc == "" { - format := "In struct: %s, field documentation is missing: %s\n" - s := fmt.Sprintf(format, structName, pair.Name) - buffer.addLine(s, 0) - missingDocs++ - } - } - } - - if err := buffer.flushLines(w); err != nil { - return -1, err - } - return missingDocs, nil -} diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/types.go b/vendor/k8s.io/apimachinery/pkg/runtime/types.go deleted file mode 100644 index 31359f35f..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/types.go +++ /dev/null @@ -1,126 +0,0 @@ -/* -Copyright 2014 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 runtime - -// Note that the types provided in this file are not versioned and are intended to be -// safe to use from within all versions of every API object. - -// TypeMeta is shared by all top level objects. The proper way to use it is to inline it in your type, -// like this: -// type MyAwesomeAPIObject struct { -// runtime.TypeMeta `json:",inline"` -// ... // other fields -// } -// func (obj *MyAwesomeAPIObject) SetGroupVersionKind(gvk *metav1.GroupVersionKind) { metav1.UpdateTypeMeta(obj,gvk) }; GroupVersionKind() *GroupVersionKind -// -// TypeMeta is provided here for convenience. You may use it directly from this package or define -// your own with the same fields. -// -// +k8s:deepcopy-gen=false -// +protobuf=true -// +k8s:openapi-gen=true -type TypeMeta struct { - // +optional - APIVersion string `json:"apiVersion,omitempty" yaml:"apiVersion,omitempty" protobuf:"bytes,1,opt,name=apiVersion"` - // +optional - Kind string `json:"kind,omitempty" yaml:"kind,omitempty" protobuf:"bytes,2,opt,name=kind"` -} - -const ( - ContentTypeJSON string = "application/json" - ContentTypeYAML string = "application/yaml" - ContentTypeProtobuf string = "application/vnd.kubernetes.protobuf" -) - -// RawExtension is used to hold extensions in external versions. -// -// To use this, make a field which has RawExtension as its type in your external, versioned -// struct, and Object in your internal struct. You also need to register your -// various plugin types. -// -// // Internal package: -// type MyAPIObject struct { -// runtime.TypeMeta `json:",inline"` -// MyPlugin runtime.Object `json:"myPlugin"` -// } -// type PluginA struct { -// AOption string `json:"aOption"` -// } -// -// // External package: -// type MyAPIObject struct { -// runtime.TypeMeta `json:",inline"` -// MyPlugin runtime.RawExtension `json:"myPlugin"` -// } -// type PluginA struct { -// AOption string `json:"aOption"` -// } -// -// // On the wire, the JSON will look something like this: -// { -// "kind":"MyAPIObject", -// "apiVersion":"v1", -// "myPlugin": { -// "kind":"PluginA", -// "aOption":"foo", -// }, -// } -// -// So what happens? Decode first uses json or yaml to unmarshal the serialized data into -// your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. -// The next step is to copy (using pkg/conversion) into the internal struct. The runtime -// package's DefaultScheme has conversion functions installed which will unpack the -// JSON stored in RawExtension, turning it into the correct object type, and storing it -// in the Object. (TODO: In the case where the object is of an unknown type, a -// runtime.Unknown object will be created and stored.) -// -// +k8s:deepcopy-gen=true -// +protobuf=true -// +k8s:openapi-gen=true -type RawExtension struct { - // Raw is the underlying serialization of this object. - // - // TODO: Determine how to detect ContentType and ContentEncoding of 'Raw' data. - Raw []byte `json:"-" protobuf:"bytes,1,opt,name=raw"` - // Object can hold a representation of this extension - useful for working with versioned - // structs. - Object Object `json:"-"` -} - -// Unknown allows api objects with unknown types to be passed-through. This can be used -// to deal with the API objects from a plug-in. Unknown objects still have functioning -// TypeMeta features-- kind, version, etc. -// TODO: Make this object have easy access to field based accessors and settors for -// metadata and field mutatation. -// -// +k8s:deepcopy-gen=true -// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object -// +protobuf=true -// +k8s:openapi-gen=true -type Unknown struct { - TypeMeta `json:",inline" protobuf:"bytes,1,opt,name=typeMeta"` - // Raw will hold the complete serialized object which couldn't be matched - // with a registered type. Most likely, nothing should be done with this - // except for passing it through the system. - Raw []byte `protobuf:"bytes,2,opt,name=raw"` - // ContentEncoding is encoding used to encode 'Raw' data. - // Unspecified means no encoding. - ContentEncoding string `protobuf:"bytes,3,opt,name=contentEncoding"` - // ContentType is serialization method used to serialize 'Raw'. - // Unspecified means ContentTypeJSON. - ContentType string `protobuf:"bytes,4,opt,name=contentType"` -} diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/types_proto.go b/vendor/k8s.io/apimachinery/pkg/runtime/types_proto.go deleted file mode 100644 index a82227b23..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/types_proto.go +++ /dev/null @@ -1,89 +0,0 @@ -/* -Copyright 2015 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 runtime - -import ( - "fmt" -) - -type ProtobufMarshaller interface { - MarshalTo(data []byte) (int, error) -} - -type ProtobufReverseMarshaller interface { - MarshalToSizedBuffer(data []byte) (int, error) -} - -// NestedMarshalTo allows a caller to avoid extra allocations during serialization of an Unknown -// that will contain an object that implements ProtobufMarshaller or ProtobufReverseMarshaller. -func (m *Unknown) NestedMarshalTo(data []byte, b ProtobufMarshaller, size uint64) (int, error) { - // Calculate the full size of the message. - msgSize := m.Size() - if b != nil { - msgSize += int(size) + sovGenerated(size) + 1 - } - - // Reverse marshal the fields of m. - i := msgSize - i -= len(m.ContentType) - copy(data[i:], m.ContentType) - i = encodeVarintGenerated(data, i, uint64(len(m.ContentType))) - i-- - data[i] = 0x22 - i -= len(m.ContentEncoding) - copy(data[i:], m.ContentEncoding) - i = encodeVarintGenerated(data, i, uint64(len(m.ContentEncoding))) - i-- - data[i] = 0x1a - if b != nil { - if r, ok := b.(ProtobufReverseMarshaller); ok { - n1, err := r.MarshalToSizedBuffer(data[:i]) - if err != nil { - return 0, err - } - i -= int(size) - if uint64(n1) != size { - // programmer error: the Size() method for protobuf does not match the results of LashramOt, which means the proto - // struct returned would be wrong. - return 0, fmt.Errorf("the Size() value of %T was %d, but NestedMarshalTo wrote %d bytes to data", b, size, n1) - } - } else { - i -= int(size) - n1, err := b.MarshalTo(data[i:]) - if err != nil { - return 0, err - } - if uint64(n1) != size { - // programmer error: the Size() method for protobuf does not match the results of MarshalTo, which means the proto - // struct returned would be wrong. - return 0, fmt.Errorf("the Size() value of %T was %d, but NestedMarshalTo wrote %d bytes to data", b, size, n1) - } - } - i = encodeVarintGenerated(data, i, size) - i-- - data[i] = 0x12 - } - n2, err := m.TypeMeta.MarshalToSizedBuffer(data[:i]) - if err != nil { - return 0, err - } - i -= n2 - i = encodeVarintGenerated(data, i, uint64(n2)) - i-- - data[i] = 0xa - return msgSize - i, nil -} diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/zz_generated.deepcopy.go b/vendor/k8s.io/apimachinery/pkg/runtime/zz_generated.deepcopy.go deleted file mode 100644 index b0393839e..000000000 --- a/vendor/k8s.io/apimachinery/pkg/runtime/zz_generated.deepcopy.go +++ /dev/null @@ -1,75 +0,0 @@ -// +build !ignore_autogenerated - -/* -Copyright 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. -*/ - -// Code generated by deepcopy-gen. DO NOT EDIT. - -package runtime - -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *RawExtension) DeepCopyInto(out *RawExtension) { - *out = *in - if in.Raw != nil { - in, out := &in.Raw, &out.Raw - *out = make([]byte, len(*in)) - copy(*out, *in) - } - if in.Object != nil { - out.Object = in.Object.DeepCopyObject() - } - return -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RawExtension. -func (in *RawExtension) DeepCopy() *RawExtension { - if in == nil { - return nil - } - out := new(RawExtension) - in.DeepCopyInto(out) - return out -} - -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *Unknown) DeepCopyInto(out *Unknown) { - *out = *in - out.TypeMeta = in.TypeMeta - if in.Raw != nil { - in, out := &in.Raw, &out.Raw - *out = make([]byte, len(*in)) - copy(*out, *in) - } - return -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Unknown. -func (in *Unknown) DeepCopy() *Unknown { - if in == nil { - return nil - } - out := new(Unknown) - in.DeepCopyInto(out) - return out -} - -// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new Object. -func (in *Unknown) DeepCopyObject() Object { - if c := in.DeepCopy(); c != nil { - return c - } - return nil -} |