K8s源码分析(8)-codec和codec factory的创建

// k8s.io/apimachinery/pkg/runtime/serializer/codec_factory.go
func newSerializersForScheme(scheme *runtime.Scheme, mf json.MetaFactory, options CodecFactoryOptions) []serializerType {
  jsonSerializer := json.NewSerializerWithOptions(
    mf, scheme, scheme,
    json.SerializerOptions{Yaml: false, Pretty: false, Strict: options.Strict},
  )
  jsonSerializerType := serializerType{
    AcceptContentTypes: []string{runtime.ContentTypeJSON},
    ContentType:        runtime.ContentTypeJSON,
    FileExtensions:     []string{"json"},
    EncodesAsText:      true,
    Serializer:         jsonSerializer,

    Framer:           json.Framer,
    StreamSerializer: jsonSerializer,
  }
  if options.Pretty {
    jsonSerializerType.PrettySerializer = json.NewSerializerWithOptions(
      mf, scheme, scheme,
      json.SerializerOptions{Yaml: false, Pretty: true, Strict: options.Strict},
    )
  }

  yamlSerializer := json.NewSerializerWithOptions(
    mf, scheme, scheme,
    json.SerializerOptions{Yaml: true, Pretty: false, Strict: options.Strict},
  )
  protoSerializer := protobuf.NewSerializer(scheme, scheme)
  protoRawSerializer := protobuf.NewRawSerializer(scheme, scheme)

  serializers := []serializerType{
    jsonSerializerType,
    {
      AcceptContentTypes: []string{runtime.ContentTypeYAML},
      ContentType:        runtime.ContentTypeYAML,
      FileExtensions:     []string{"yaml"},
      EncodesAsText:      true,
      Serializer:         yamlSerializer,
    },
    {
      AcceptContentTypes: []string{runtime.ContentTypeProtobuf},
      ContentType:        runtime.ContentTypeProtobuf,
      FileExtensions:     []string{"pb"},
      Serializer:         protoSerializer,

      Framer:           protobuf.LengthDelimitedFramer,
      StreamSerializer: protoRawSerializer,
    },
  }

  for _, fn := range serializerExtensions {
    if serializer, ok := fn(scheme); ok {
      serializers = append(serializers, serializer)
    }
  }
  return serializers
}

// k8s.io/apimachinery/pkg/runtime/serializer/codec_factory.go
func newCodecFactory(scheme *runtime.Scheme, serializers []serializerType) CodecFactory {
  decoders := make([]runtime.Decoder, 0, len(serializers))
  var accepts []runtime.SerializerInfo
  alreadyAccepted := make(map[string]struct{})

  var legacySerializer runtime.Serializer
  for _, d := range serializers {
    decoders = append(decoders, d.Serializer)
    for _, mediaType := range d.AcceptContentTypes {
      if _, ok := alreadyAccepted[mediaType]; ok {
        continue
      }
      alreadyAccepted[mediaType] = struct{}{}
      info := runtime.SerializerInfo{
        MediaType:        d.ContentType,
        EncodesAsText:    d.EncodesAsText,
        Serializer:       d.Serializer,
        PrettySerializer: d.PrettySerializer,
      }

      mediaType, _, err := mime.ParseMediaType(info.MediaType)
      if err != nil {
        panic(err)
      }
      parts := strings.SplitN(mediaType, "/", 2)
      info.MediaTypeType = parts[0]
      info.MediaTypeSubType = parts[1]

      if d.StreamSerializer != nil {
        info.StreamSerializer = &runtime.StreamSerializerInfo{
          Serializer:    d.StreamSerializer,
          EncodesAsText: d.EncodesAsText,
          Framer:        d.Framer,
        }
      }
      accepts = append(accepts, info)
      if mediaType == runtime.ContentTypeJSON {
        legacySerializer = d.Serializer
      }
    }
  }
  if legacySerializer == nil {
    legacySerializer = serializers[0].Serializer
  }

  return CodecFactory{
    scheme:    scheme,
    universal: recognizer.NewDecoder(decoders...),

    accepts: accepts,

    legacySerializer: legacySerializer,
  }
}

// k8s.io/apimachinery/pkg/runtime/serializer/codec_factory.go
func (f CodecFactory) DecoderToVersion(decoder runtime.Decoder, gv runtime.GroupVersioner) runtime.Decoder {
  return f.CodecForVersions(nil, decoder, nil, gv)
}

func (f CodecFactory) EncoderForVersion(encoder runtime.Encoder, gv runtime.GroupVersioner) runtime.Encoder {
  return f.CodecForVersions(encoder, nil, gv, nil)
}

func (f CodecFactory) CodecForVersions(encoder runtime.Encoder, decoder runtime.Decoder, encode runtime.GroupVersioner, decode runtime.GroupVersioner) runtime.Codec {
  // TODO: these are for backcompat, remove them in the future
  if encode == nil {
    encode = runtime.DisabledGroupVersioner
  }
  if decode == nil {
    decode = runtime.InternalGroupVersioner
  }
  return versioning.NewDefaultingCodecForScheme(f.scheme, encoder, decoder, encode, decode)
}

// staging/src/k8s.io/apimachinery/pkg/runtime/serializer/versioning/versioning.go
func NewDefaultingCodecForScheme(
  scheme *runtime.Scheme,
  encoder runtime.Encoder,
  decoder runtime.Decoder,
  encodeVersion runtime.GroupVersioner,
  decodeVersion runtime.GroupVersioner,
) runtime.Codec {
  return NewCodec(encoder, decoder, runtime.UnsafeObjectConvertor(scheme), scheme, scheme, scheme, encodeVersion, decodeVersion, scheme.Name())
}

func NewCodec(
  encoder runtime.Encoder,
  decoder runtime.Decoder,
  convertor runtime.ObjectConvertor,
  creater runtime.ObjectCreater,
  typer runtime.ObjectTyper,
  defaulter runtime.ObjectDefaulter,
  encodeVersion runtime.GroupVersioner,
  decodeVersion runtime.GroupVersioner,
  originalSchemeName string,
) runtime.Codec {
  internal := &codec{
    encoder:   encoder,
    decoder:   decoder,
    convertor: convertor,
    creater:   creater,
    typer:     typer,
    defaulter: defaulter,

    encodeVersion: encodeVersion,
    decodeVersion: decodeVersion,

    identifier: identifier(encodeVersion, encoder),

    originalSchemeName: originalSchemeName,
  }
  return internal
}