mirror of
https://github.com/kubernetes/sample-controller.git
synced 2025-02-12 17:42:59 +08:00
c4b5a29669
Automatic merge from submit-queue. If you want to cherry-pick this change to another branch, please follow the instructions <a href="https://github.com/kubernetes/community/blob/master/contributors/devel/cherry-picks.md">here</a>. Make kubernetes json serializer case sensitive This PR imported the latest jsoniterator library so that case sensitivity during unmarhsaling is optional. The PR also set Kubernetes json serializer to be case sensitive. Kubernetes json serializer had been case sensitive for 1.1-1.7 as we were using ugorji. This PR restores the behavior. Fix #64612. ```release-notes Kubernetes json deserializer is now case-sensitive as it was before 1.8. If your config files contains fields with wrong case, the config files will be now invalid. ``` Kubernetes-commit: a2de1398f829ef38d645579160bdd6bfec8384d3
452 lines
11 KiB
Go
452 lines
11 KiB
Go
package jsoniter
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"reflect"
|
|
"strconv"
|
|
"unsafe"
|
|
|
|
"github.com/modern-go/reflect2"
|
|
)
|
|
|
|
const ptrSize = 32 << uintptr(^uintptr(0)>>63)
|
|
|
|
func createEncoderOfNative(ctx *ctx, typ reflect2.Type) ValEncoder {
|
|
if typ.Kind() == reflect.Slice && typ.(reflect2.SliceType).Elem().Kind() == reflect.Uint8 {
|
|
sliceDecoder := decoderOfSlice(ctx, typ)
|
|
return &base64Codec{sliceDecoder: sliceDecoder}
|
|
}
|
|
typeName := typ.String()
|
|
kind := typ.Kind()
|
|
switch kind {
|
|
case reflect.String:
|
|
if typeName != "string" {
|
|
return encoderOfType(ctx, reflect2.TypeOfPtr((*string)(nil)).Elem())
|
|
}
|
|
return &stringCodec{}
|
|
case reflect.Int:
|
|
if typeName != "int" {
|
|
return encoderOfType(ctx, reflect2.TypeOfPtr((*int)(nil)).Elem())
|
|
}
|
|
if strconv.IntSize == 32 {
|
|
return &int32Codec{}
|
|
}
|
|
return &int64Codec{}
|
|
case reflect.Int8:
|
|
if typeName != "int8" {
|
|
return encoderOfType(ctx, reflect2.TypeOfPtr((*int8)(nil)).Elem())
|
|
}
|
|
return &int8Codec{}
|
|
case reflect.Int16:
|
|
if typeName != "int16" {
|
|
return encoderOfType(ctx, reflect2.TypeOfPtr((*int16)(nil)).Elem())
|
|
}
|
|
return &int16Codec{}
|
|
case reflect.Int32:
|
|
if typeName != "int32" {
|
|
return encoderOfType(ctx, reflect2.TypeOfPtr((*int32)(nil)).Elem())
|
|
}
|
|
return &int32Codec{}
|
|
case reflect.Int64:
|
|
if typeName != "int64" {
|
|
return encoderOfType(ctx, reflect2.TypeOfPtr((*int64)(nil)).Elem())
|
|
}
|
|
return &int64Codec{}
|
|
case reflect.Uint:
|
|
if typeName != "uint" {
|
|
return encoderOfType(ctx, reflect2.TypeOfPtr((*uint)(nil)).Elem())
|
|
}
|
|
if strconv.IntSize == 32 {
|
|
return &uint32Codec{}
|
|
}
|
|
return &uint64Codec{}
|
|
case reflect.Uint8:
|
|
if typeName != "uint8" {
|
|
return encoderOfType(ctx, reflect2.TypeOfPtr((*uint8)(nil)).Elem())
|
|
}
|
|
return &uint8Codec{}
|
|
case reflect.Uint16:
|
|
if typeName != "uint16" {
|
|
return encoderOfType(ctx, reflect2.TypeOfPtr((*uint16)(nil)).Elem())
|
|
}
|
|
return &uint16Codec{}
|
|
case reflect.Uint32:
|
|
if typeName != "uint32" {
|
|
return encoderOfType(ctx, reflect2.TypeOfPtr((*uint32)(nil)).Elem())
|
|
}
|
|
return &uint32Codec{}
|
|
case reflect.Uintptr:
|
|
if typeName != "uintptr" {
|
|
return encoderOfType(ctx, reflect2.TypeOfPtr((*uintptr)(nil)).Elem())
|
|
}
|
|
if ptrSize == 32 {
|
|
return &uint32Codec{}
|
|
}
|
|
return &uint64Codec{}
|
|
case reflect.Uint64:
|
|
if typeName != "uint64" {
|
|
return encoderOfType(ctx, reflect2.TypeOfPtr((*uint64)(nil)).Elem())
|
|
}
|
|
return &uint64Codec{}
|
|
case reflect.Float32:
|
|
if typeName != "float32" {
|
|
return encoderOfType(ctx, reflect2.TypeOfPtr((*float32)(nil)).Elem())
|
|
}
|
|
return &float32Codec{}
|
|
case reflect.Float64:
|
|
if typeName != "float64" {
|
|
return encoderOfType(ctx, reflect2.TypeOfPtr((*float64)(nil)).Elem())
|
|
}
|
|
return &float64Codec{}
|
|
case reflect.Bool:
|
|
if typeName != "bool" {
|
|
return encoderOfType(ctx, reflect2.TypeOfPtr((*bool)(nil)).Elem())
|
|
}
|
|
return &boolCodec{}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func createDecoderOfNative(ctx *ctx, typ reflect2.Type) ValDecoder {
|
|
if typ.Kind() == reflect.Slice && typ.(reflect2.SliceType).Elem().Kind() == reflect.Uint8 {
|
|
sliceDecoder := decoderOfSlice(ctx, typ)
|
|
return &base64Codec{sliceDecoder: sliceDecoder}
|
|
}
|
|
typeName := typ.String()
|
|
switch typ.Kind() {
|
|
case reflect.String:
|
|
if typeName != "string" {
|
|
return decoderOfType(ctx, reflect2.TypeOfPtr((*string)(nil)).Elem())
|
|
}
|
|
return &stringCodec{}
|
|
case reflect.Int:
|
|
if typeName != "int" {
|
|
return decoderOfType(ctx, reflect2.TypeOfPtr((*int)(nil)).Elem())
|
|
}
|
|
if strconv.IntSize == 32 {
|
|
return &int32Codec{}
|
|
}
|
|
return &int64Codec{}
|
|
case reflect.Int8:
|
|
if typeName != "int8" {
|
|
return decoderOfType(ctx, reflect2.TypeOfPtr((*int8)(nil)).Elem())
|
|
}
|
|
return &int8Codec{}
|
|
case reflect.Int16:
|
|
if typeName != "int16" {
|
|
return decoderOfType(ctx, reflect2.TypeOfPtr((*int16)(nil)).Elem())
|
|
}
|
|
return &int16Codec{}
|
|
case reflect.Int32:
|
|
if typeName != "int32" {
|
|
return decoderOfType(ctx, reflect2.TypeOfPtr((*int32)(nil)).Elem())
|
|
}
|
|
return &int32Codec{}
|
|
case reflect.Int64:
|
|
if typeName != "int64" {
|
|
return decoderOfType(ctx, reflect2.TypeOfPtr((*int64)(nil)).Elem())
|
|
}
|
|
return &int64Codec{}
|
|
case reflect.Uint:
|
|
if typeName != "uint" {
|
|
return decoderOfType(ctx, reflect2.TypeOfPtr((*uint)(nil)).Elem())
|
|
}
|
|
if strconv.IntSize == 32 {
|
|
return &uint32Codec{}
|
|
}
|
|
return &uint64Codec{}
|
|
case reflect.Uint8:
|
|
if typeName != "uint8" {
|
|
return decoderOfType(ctx, reflect2.TypeOfPtr((*uint8)(nil)).Elem())
|
|
}
|
|
return &uint8Codec{}
|
|
case reflect.Uint16:
|
|
if typeName != "uint16" {
|
|
return decoderOfType(ctx, reflect2.TypeOfPtr((*uint16)(nil)).Elem())
|
|
}
|
|
return &uint16Codec{}
|
|
case reflect.Uint32:
|
|
if typeName != "uint32" {
|
|
return decoderOfType(ctx, reflect2.TypeOfPtr((*uint32)(nil)).Elem())
|
|
}
|
|
return &uint32Codec{}
|
|
case reflect.Uintptr:
|
|
if typeName != "uintptr" {
|
|
return decoderOfType(ctx, reflect2.TypeOfPtr((*uintptr)(nil)).Elem())
|
|
}
|
|
if ptrSize == 32 {
|
|
return &uint32Codec{}
|
|
}
|
|
return &uint64Codec{}
|
|
case reflect.Uint64:
|
|
if typeName != "uint64" {
|
|
return decoderOfType(ctx, reflect2.TypeOfPtr((*uint64)(nil)).Elem())
|
|
}
|
|
return &uint64Codec{}
|
|
case reflect.Float32:
|
|
if typeName != "float32" {
|
|
return decoderOfType(ctx, reflect2.TypeOfPtr((*float32)(nil)).Elem())
|
|
}
|
|
return &float32Codec{}
|
|
case reflect.Float64:
|
|
if typeName != "float64" {
|
|
return decoderOfType(ctx, reflect2.TypeOfPtr((*float64)(nil)).Elem())
|
|
}
|
|
return &float64Codec{}
|
|
case reflect.Bool:
|
|
if typeName != "bool" {
|
|
return decoderOfType(ctx, reflect2.TypeOfPtr((*bool)(nil)).Elem())
|
|
}
|
|
return &boolCodec{}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type stringCodec struct {
|
|
}
|
|
|
|
func (codec *stringCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
|
|
*((*string)(ptr)) = iter.ReadString()
|
|
}
|
|
|
|
func (codec *stringCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
|
|
str := *((*string)(ptr))
|
|
stream.WriteString(str)
|
|
}
|
|
|
|
func (codec *stringCodec) IsEmpty(ptr unsafe.Pointer) bool {
|
|
return *((*string)(ptr)) == ""
|
|
}
|
|
|
|
type int8Codec struct {
|
|
}
|
|
|
|
func (codec *int8Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
|
|
if !iter.ReadNil() {
|
|
*((*int8)(ptr)) = iter.ReadInt8()
|
|
}
|
|
}
|
|
|
|
func (codec *int8Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
|
|
stream.WriteInt8(*((*int8)(ptr)))
|
|
}
|
|
|
|
func (codec *int8Codec) IsEmpty(ptr unsafe.Pointer) bool {
|
|
return *((*int8)(ptr)) == 0
|
|
}
|
|
|
|
type int16Codec struct {
|
|
}
|
|
|
|
func (codec *int16Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
|
|
if !iter.ReadNil() {
|
|
*((*int16)(ptr)) = iter.ReadInt16()
|
|
}
|
|
}
|
|
|
|
func (codec *int16Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
|
|
stream.WriteInt16(*((*int16)(ptr)))
|
|
}
|
|
|
|
func (codec *int16Codec) IsEmpty(ptr unsafe.Pointer) bool {
|
|
return *((*int16)(ptr)) == 0
|
|
}
|
|
|
|
type int32Codec struct {
|
|
}
|
|
|
|
func (codec *int32Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
|
|
if !iter.ReadNil() {
|
|
*((*int32)(ptr)) = iter.ReadInt32()
|
|
}
|
|
}
|
|
|
|
func (codec *int32Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
|
|
stream.WriteInt32(*((*int32)(ptr)))
|
|
}
|
|
|
|
func (codec *int32Codec) IsEmpty(ptr unsafe.Pointer) bool {
|
|
return *((*int32)(ptr)) == 0
|
|
}
|
|
|
|
type int64Codec struct {
|
|
}
|
|
|
|
func (codec *int64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
|
|
if !iter.ReadNil() {
|
|
*((*int64)(ptr)) = iter.ReadInt64()
|
|
}
|
|
}
|
|
|
|
func (codec *int64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
|
|
stream.WriteInt64(*((*int64)(ptr)))
|
|
}
|
|
|
|
func (codec *int64Codec) IsEmpty(ptr unsafe.Pointer) bool {
|
|
return *((*int64)(ptr)) == 0
|
|
}
|
|
|
|
type uint8Codec struct {
|
|
}
|
|
|
|
func (codec *uint8Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
|
|
if !iter.ReadNil() {
|
|
*((*uint8)(ptr)) = iter.ReadUint8()
|
|
}
|
|
}
|
|
|
|
func (codec *uint8Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
|
|
stream.WriteUint8(*((*uint8)(ptr)))
|
|
}
|
|
|
|
func (codec *uint8Codec) IsEmpty(ptr unsafe.Pointer) bool {
|
|
return *((*uint8)(ptr)) == 0
|
|
}
|
|
|
|
type uint16Codec struct {
|
|
}
|
|
|
|
func (codec *uint16Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
|
|
if !iter.ReadNil() {
|
|
*((*uint16)(ptr)) = iter.ReadUint16()
|
|
}
|
|
}
|
|
|
|
func (codec *uint16Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
|
|
stream.WriteUint16(*((*uint16)(ptr)))
|
|
}
|
|
|
|
func (codec *uint16Codec) IsEmpty(ptr unsafe.Pointer) bool {
|
|
return *((*uint16)(ptr)) == 0
|
|
}
|
|
|
|
type uint32Codec struct {
|
|
}
|
|
|
|
func (codec *uint32Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
|
|
if !iter.ReadNil() {
|
|
*((*uint32)(ptr)) = iter.ReadUint32()
|
|
}
|
|
}
|
|
|
|
func (codec *uint32Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
|
|
stream.WriteUint32(*((*uint32)(ptr)))
|
|
}
|
|
|
|
func (codec *uint32Codec) IsEmpty(ptr unsafe.Pointer) bool {
|
|
return *((*uint32)(ptr)) == 0
|
|
}
|
|
|
|
type uint64Codec struct {
|
|
}
|
|
|
|
func (codec *uint64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
|
|
if !iter.ReadNil() {
|
|
*((*uint64)(ptr)) = iter.ReadUint64()
|
|
}
|
|
}
|
|
|
|
func (codec *uint64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
|
|
stream.WriteUint64(*((*uint64)(ptr)))
|
|
}
|
|
|
|
func (codec *uint64Codec) IsEmpty(ptr unsafe.Pointer) bool {
|
|
return *((*uint64)(ptr)) == 0
|
|
}
|
|
|
|
type float32Codec struct {
|
|
}
|
|
|
|
func (codec *float32Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
|
|
if !iter.ReadNil() {
|
|
*((*float32)(ptr)) = iter.ReadFloat32()
|
|
}
|
|
}
|
|
|
|
func (codec *float32Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
|
|
stream.WriteFloat32(*((*float32)(ptr)))
|
|
}
|
|
|
|
func (codec *float32Codec) IsEmpty(ptr unsafe.Pointer) bool {
|
|
return *((*float32)(ptr)) == 0
|
|
}
|
|
|
|
type float64Codec struct {
|
|
}
|
|
|
|
func (codec *float64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
|
|
if !iter.ReadNil() {
|
|
*((*float64)(ptr)) = iter.ReadFloat64()
|
|
}
|
|
}
|
|
|
|
func (codec *float64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
|
|
stream.WriteFloat64(*((*float64)(ptr)))
|
|
}
|
|
|
|
func (codec *float64Codec) IsEmpty(ptr unsafe.Pointer) bool {
|
|
return *((*float64)(ptr)) == 0
|
|
}
|
|
|
|
type boolCodec struct {
|
|
}
|
|
|
|
func (codec *boolCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
|
|
if !iter.ReadNil() {
|
|
*((*bool)(ptr)) = iter.ReadBool()
|
|
}
|
|
}
|
|
|
|
func (codec *boolCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
|
|
stream.WriteBool(*((*bool)(ptr)))
|
|
}
|
|
|
|
func (codec *boolCodec) IsEmpty(ptr unsafe.Pointer) bool {
|
|
return !(*((*bool)(ptr)))
|
|
}
|
|
|
|
type base64Codec struct {
|
|
sliceType *reflect2.UnsafeSliceType
|
|
sliceDecoder ValDecoder
|
|
}
|
|
|
|
func (codec *base64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
|
|
if iter.ReadNil() {
|
|
codec.sliceType.UnsafeSetNil(ptr)
|
|
return
|
|
}
|
|
switch iter.WhatIsNext() {
|
|
case StringValue:
|
|
src := iter.ReadString()
|
|
dst, err := base64.StdEncoding.DecodeString(src)
|
|
if err != nil {
|
|
iter.ReportError("decode base64", err.Error())
|
|
} else {
|
|
codec.sliceType.UnsafeSet(ptr, unsafe.Pointer(&dst))
|
|
}
|
|
case ArrayValue:
|
|
codec.sliceDecoder.Decode(ptr, iter)
|
|
default:
|
|
iter.ReportError("base64Codec", "invalid input")
|
|
}
|
|
}
|
|
|
|
func (codec *base64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
|
|
src := *((*[]byte)(ptr))
|
|
if len(src) == 0 {
|
|
stream.WriteNil()
|
|
return
|
|
}
|
|
encoding := base64.StdEncoding
|
|
stream.writeByte('"')
|
|
size := encoding.EncodedLen(len(src))
|
|
buf := make([]byte, size)
|
|
encoding.Encode(buf, src)
|
|
stream.buf = append(stream.buf, buf...)
|
|
stream.writeByte('"')
|
|
}
|
|
|
|
func (codec *base64Codec) IsEmpty(ptr unsafe.Pointer) bool {
|
|
return len(*((*[]byte)(ptr))) == 0
|
|
}
|