1. package json
    3. import (
    4.     "encoding/json"
    5.     "io"
    6.     "strconv"
    7.     "unsafe"
    9.     jsoniter "github.com/json-iterator/go"
    10.     "github.com/modern-go/reflect2"
    11.     "sigs.k8s.io/yaml"
    13.     "k8s.io/apimachinery/pkg/runtime"
    14.     "k8s.io/apimachinery/pkg/runtime/schema"
    15.     "k8s.io/apimachinery/pkg/runtime/serializer/recognizer"
    16.     "k8s.io/apimachinery/pkg/util/framer"
    17.     utilyaml "k8s.io/apimachinery/pkg/util/yaml"
    18.     "k8s.io/klog"
    19. )
    21. var _ runtime.Serializer = &Serializer{}
    22. var _ recognizer.RecognizingDecoder = &Serializer{}
    24. // Private copies of jsoniter to try to shield against possible mutations
    25. // from outside. Still does not protect from package level jsoniter.Register*() functions - someone calling them
    26. // in some other library will mess with every usage of the jsoniter library in the whole program.
    27. // See https://github.com/json-iterator/go/issues/265
    28. var caseSensitiveJsonIterator = CaseSensitiveJsonIterator()
    29. var strictCaseSensitiveJsonIterator = StrictCaseSensitiveJsonIterator()
    31. func NewSerializer(meta MetaFactory, creater runtime.ObjectCreater, typer runtime.ObjectTyper, pretty bool) *Serializer {
    32.     return NewSerializerWithOptions(meta, creater, typer, SerializerOptions{false, pretty, false})
    33. }
    35. func NewYAMLSerializer(meta MetaFactory, creater runtime.ObjectCreater, typer runtime.ObjectTyper) *Serializer {
    36.     return NewSerializerWithOptions(meta, creater, typer, SerializerOptions{true, false, false})
    37. }
    39. func NewSerializerWithOptions(meta MetaFactory, creater runtime.ObjectCreater, typer runtime.ObjectTyper, options SerializerOptions) *Serializer {
    40.     return &Serializer{
    41.         meta:       meta,
    42.         creater:    creater,
    43.         typer:      typer,
    44.         options:    options,
    45.         identifier: identifier(options),
    46.     }
    47. }
    49. type Serializer struct {
    50.     meta       MetaFactory
    51.     options    SerializerOptions
    52.     creater    runtime.ObjectCreater
    53.     typer      runtime.ObjectTyper
    54.     identifier runtime.Identifier
    55. }
    57. type SerializerOptions struct {
    58.     Yaml   bool
    59.     Pretty bool
    60.     Strict bool
    61. }
    63. type customNumberExtension struct {
    64.     jsoniter.DummyExtension
    65. }
    67. func (cne *customNumberExtension) CreateDecoder(typ reflect2.Type) jsoniter.ValDecoder {
    68.     if typ.String() == "interface {}" {
    69.         return customNumberDecoder{}
    70.     }
    71.     return nil
    72. }
    74. type customNumberDecoder struct {
    75. }
    77. func (customNumberDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
    78.     switch iter.WhatIsNext() {
    79.     case jsoniter.NumberValue:
    80.         var number jsoniter.Number
    81.         iter.ReadVal(&number)
    82.         i64, err := strconv.ParseInt(string(number), 10, 64)
    83.         if err == nil {
    84.             *(*interface{})(ptr) = i64
    85.             return
    86.         }
    87.         f64, err := strconv.ParseFloat(string(number), 64)
    88.         if err == nil {
    89.             *(*interface{})(ptr) = f64
    90.             return
    91.         }
    92.         iter.ReportError("DecodeNumber", err.Error())
    93.     default:
    94.         *(*interface{})(ptr) = iter.Read()
    95.     }
    96. }
    98. // Decode attempts to convert the provided data into YAML or JSON, extract the stored schema kind, apply the provided default gvk, and then
    99. // load that data into an object matching the desired schema kind or the provided into.
    100. // If into is *runtime.Unknown, the raw data will be extracted and no decoding will be performed.
    101. // If into is not registered with the typer, then the object will be straight decoded using normal JSON/YAML unmarshalling.
    102. // If into is provided and the original data is not fully qualified with kind/version/group, the type of the into will be used to alter the returned gvk.
    103. // If into is nil or data's gvk different from into's gvk, it will generate a new Object with ObjectCreater.New(gvk)
    104. // On success or most errors, the method will return the calculated schema kind.
    105. // The gvk calculate priority will be originalData > default gvk > into
    106. func (s *Serializer) Decode(originalData []byte, gvk *schema.GroupVersionKind, into runtime.Object) (runtime.Object, *schema.GroupVersionKind, error) {
    107.     // 反序列化
    108.     data := originalData
    109.     if s.options.Yaml {
    110.         altered, err := yaml.YAMLToJSON(data)
    111.         if err != nil {
    112.             return nil, nil, err
    113.         }
    114.         data = altered
    115.     }
    117.     // 获取gvk信息
    118.     // 先反序列化获取gvk信息
    119.     // 然后和默认gvk diff，返回实际的gvk信息
    120.     actual, err := s.meta.Interpret(data)
    121.     if err != nil {
    122.         return nil, nil, err
    123.     }
    124.     if gvk != nil {
    125.         *actual = gvkWithDefaults(*actual, *gvk)
    126.     }
    128.     if unk, ok := into.(*runtime.Unknown); ok && unk != nil {
    129.         unk.Raw = originalData
    130.         unk.ContentType = runtime.ContentTypeJSON
    131.         unk.GetObjectKind().SetGroupVersionKind(*actual)
    132.         return unk, actual, nil
    133.     }
    135.     if into != nil {
    136.         // 动态客户端一般会用此obj(某些语言没有go对应的struct)
    137.         _, isUnstructured := into.(runtime.Unstructured)
    138.         types, _, err := s.typer.ObjectKinds(into)
    139.         switch {
    140.         case runtime.IsNotRegisteredError(err), isUnstructured:
    141.             if err := caseSensitiveJsonIterator.Unmarshal(data, into); err != nil {
    142.                 return nil, actual, err
    143.             }
    144.             return into, actual, nil
    145.         case err != nil:
    146.             return nil, actual, err
    147.         default:
    148.             *actual = gvkWithDefaults(*actual, types[0])
    149.         }
    150.     }
    152.     if len(actual.Kind) == 0 {
    153.         return nil, actual, runtime.NewMissingKindErr(string(originalData))
    154.     }
    155.     if len(actual.Version) == 0 {
    156.         return nil, actual, runtime.NewMissingVersionErr(string(originalData))
    157.     }
    159.     // use the target if necessary
    160.     obj, err := runtime.UseOrCreateObject(s.typer, s.creater, *actual, into)
    161.     if err != nil {
    162.         return nil, actual, err
    163.     }
    165.     if err := caseSensitiveJsonIterator.Unmarshal(data, obj); err != nil {
    166.         return nil, actual, err
    167.     }
    169.     // If the deserializer is non-strict, return successfully here.
    170.     if !s.options.Strict {
    171.         return obj, actual, nil
    172.     }
    174.     // In strict mode pass the data trough the YAMLToJSONStrict converter.
    175.     // This is done to catch duplicate fields regardless of encoding (JSON or YAML). For JSON data,
    176.     // the output would equal the input, unless there is a parsing error such as duplicate fields.
    177.     // As we know this was successful in the non-strict case, the only error that may be returned here
    178.     // is because of the newly-added strictness. hence we know we can return the typed strictDecoderError
    179.     // the actual error is that the object contains duplicate fields.
    180.     altered, err := yaml.YAMLToJSONStrict(originalData)
    181.     if err != nil {
    182.         return nil, actual, runtime.NewStrictDecodingError(err.Error(), string(originalData))
    183.     }
    184.     // As performance is not an issue for now for the strict deserializer (one has regardless to do
    185.     // the unmarshal twice), we take the sanitized, altered data that is guaranteed to have no duplicated
    186.     // fields, and unmarshal this into a copy of the already-populated obj. Any error that occurs here is
    187.     // due to that a matching field doesn't exist in the object. hence we can return a typed strictDecoderError,
    188.     // the actual error is that the object contains unknown field.
    189.     strictObj := obj.DeepCopyObject()
    190.     if err := strictCaseSensitiveJsonIterator.Unmarshal(altered, strictObj); err != nil {
    191.         return nil, actual, runtime.NewStrictDecodingError(err.Error(), string(originalData))
    192.     }
    193.     // Always return the same object as the non-strict serializer to avoid any deviations.
    194.     return obj, actual, nil
    195. }
    197. // Encode serializes the provided object to the given writer.
    198. func (s *Serializer) Encode(obj runtime.Object, w io.Writer) error {
    199.     if co, ok := obj.(runtime.CacheableObject); ok {
    200.         return co.CacheEncode(s.Identifier(), s.doEncode, w)
    201.     }
    202.     return s.doEncode(obj, w)
    203. }
    205. func (s *Serializer) doEncode(obj runtime.Object, w io.Writer) error {
    206.     if s.options.Yaml {
    207.         jsonData, err := caseSensitiveJsonIterator.Marshal(obj)
    208.         if err != nil {
    209.             return err
    210.         }
    211.         data, err := yaml.JSONToYAML(jsonData)
    212.         if err != nil {
    213.             return err
    214.         }
    215.         _, err = w.Write(data)
    216.         return err
    217.     }
    219.     if s.options.Pretty {
    220.         data, err := caseSensitiveJsonIterator.MarshalIndent(obj, "", "  ")
    221.         if err != nil {
    222.             return err
    223.         }
    224.         _, err = w.Write(data)
    225.         return err
    226.     }
    228.     encoder := json.NewEncoder(w)
    229.     return encoder.Encode(obj)
    230. }
    232. func (s *Serializer) Identifier() runtime.Identifier {
    233.     return s.identifier
    234. }
    236. func (s *Serializer) RecognizesData(peek io.Reader) (ok, unknown bool, err error) {
    237.     if s.options.Yaml {
    238.         return false, true, nil
    239.     }
    240.     _, _, ok = utilyaml.GuessJSONStream(peek, 2048)
    241.     return ok, false, nil
    242. }
    244. var Framer = jsonFramer{}
    246. type jsonFramer struct{}
    248. func (jsonFramer) NewFrameWriter(w io.Writer) io.Writer {
    249.     return w
    250. }
    252. func (jsonFramer) NewFrameReader(r io.ReadCloser) io.ReadCloser {
    253.     return framer.NewJSONFramedReader(r)
    254. }
    256. var YAMLFramer = yamlFramer{}
    258. type yamlFramer struct{}
    260. func (yamlFramer) NewFrameWriter(w io.Writer) io.Writer {
    261.     return yamlFrameWriter{w}
    262. }
    264. func (yamlFramer) NewFrameReader(r io.ReadCloser) io.ReadCloser {
    265.     return utilyaml.NewDocumentDecoder(r)
    266. }
    268. type yamlFrameWriter struct {
    269.     w io.Writer
    270. }
    272. func (w yamlFrameWriter) Write(data []byte) (n int, err error) {
    273.     if _, err := w.w.Write([]byte("---\n")); err != nil {
    274.         return 0, err
    275.     }
    276.     return w.w.Write(data)
    277. }
    279. //---------------------------------------
    280. //---------------工具函数-----------------
    281. //---------------------------------------
    282. // CaseSensitiveJsonIterator returns a jsoniterator API that's configured to be
    283. // case-sensitive when unmarshalling, and otherwise compatible with
    284. // the encoding/json standard library.
    285. func CaseSensitiveJsonIterator() jsoniter.API {
    286.     config := jsoniter.Config{
    287.         EscapeHTML:             true,
    288.         SortMapKeys:            true,
    289.         ValidateJsonRawMessage: true,
    290.         CaseSensitive:          true,
    291.     }.Froze()
    292.     // Force jsoniter to decode number to interface{} via int64/float64, if possible.
    293.     config.RegisterExtension(&customNumberExtension{})
    294.     return config
    295. }
    297. // StrictCaseSensitiveJsonIterator returns a jsoniterator API that's configured to be
    298. // case-sensitive, but also disallows unknown fields when unmarshalling. It is compatible with
    299. // the encoding/json standard library.
    300. func StrictCaseSensitiveJsonIterator() jsoniter.API {
    301.     config := jsoniter.Config{
    302.         EscapeHTML:             true,
    303.         SortMapKeys:            true,
    304.         ValidateJsonRawMessage: true,
    305.         CaseSensitive:          true,
    306.         DisallowUnknownFields:  true,
    307.     }.Froze()
    308.     // Force jsoniter to decode number to interface{} via int64/float64, if possible.
    309.     config.RegisterExtension(&customNumberExtension{})
    310.     return config
    311. }
    313. func gvkWithDefaults(actual, defaultGVK schema.GroupVersionKind) schema.GroupVersionKind {
    314.     if len(actual.Kind) == 0 {
    315.         actual.Kind = defaultGVK.Kind
    316.     }
    317.     if len(actual.Version) == 0 && len(actual.Group) == 0 {
    318.         actual.Group = defaultGVK.Group
    319.         actual.Version = defaultGVK.Version
    320.     }
    321.     if len(actual.Version) == 0 && actual.Group == defaultGVK.Group {
    322.         actual.Version = defaultGVK.Version
    323.     }
    324.     return actual
    325. }
    327. func identifier(options SerializerOptions) runtime.Identifier {
    328.     result := map[string]string{
    329.         "name":   "json",
    330.         "yaml":   strconv.FormatBool(options.Yaml),
    331.         "pretty": strconv.FormatBool(options.Pretty),
    332.     }
    333.     identifier, err := json.Marshal(result)
    334.     if err != nil {
    335.         klog.Fatalf("Failed marshaling identifier for json Serializer: %v", err)
    336.     }
    337.     return runtime.Identifier(identifier)
    338. }