K8s源码分析(9)-codec的decode和encode操作

// staging/src/k8s.io/apimachinery/pkg/runtime/serializer/versioning/versioning.go
func (c *codec) Decode(data []byte, defaultGVK *schema.GroupVersionKind, into runtime.Object) (runtime.Object, *schema.GroupVersionKind, error) {
  // If the into object is unstructured and expresses an opinion about its group/version,
  // create a new instance of the type so we always exercise the conversion path (skips short-circuiting on `into == obj`)
  decodeInto := into
  if into != nil {
    if _, ok := into.(runtime.Unstructured); ok && !into.GetObjectKind().GroupVersionKind().GroupVersion().Empty() {
      decodeInto = reflect.New(reflect.TypeOf(into).Elem()).Interface().(runtime.Object)
    }
  }


  obj, gvk, err := c.decoder.Decode(data, defaultGVK, decodeInto)
  if err != nil {
    return nil, gvk, err
  }


  if d, ok := obj.(runtime.NestedObjectDecoder); ok {
    if err := d.DecodeNestedObjects(runtime.WithoutVersionDecoder{c.decoder}); err != nil {
      return nil, gvk, err
    }
  }


  // if we specify a target, use generic conversion.
  if into != nil {
    // perform defaulting if requested
    if c.defaulter != nil {
      c.defaulter.Default(obj)
    }


    // Short-circuit conversion if the into object is same object
    if into == obj {
      return into, gvk, nil
    }


    if err := c.convertor.Convert(obj, into, c.decodeVersion); err != nil {
      return nil, gvk, err
    }


    return into, gvk, nil
  }


  // perform defaulting if requested
  if c.defaulter != nil {
    c.defaulter.Default(obj)
  }


  out, err := c.convertor.ConvertToVersion(obj, c.decodeVersion)
  if err != nil {
    return nil, gvk, err
  }
  return out, gvk, nil
}

// staging/src/k8s.io/apimachinery/pkg/runtime/serializer/versioning/versioning.go
func (c *codec) doEncode(obj runtime.Object, w io.Writer) error {
  switch obj := obj.(type) {
  case *runtime.Unknown:
    return c.encoder.Encode(obj, w)
  case runtime.Unstructured:
    // An unstructured list can contain objects of multiple group version kinds. don't short-circuit just
    // because the top-level type matches our desired destination type. actually send the object to the converter
    // to give it a chance to convert the list items if needed.
    if _, ok := obj.(*unstructured.UnstructuredList); !ok {
      // avoid conversion roundtrip if GVK is the right one already or is empty (yes, this is a hack, but the old behaviour we rely on in kubectl)
      objGVK := obj.GetObjectKind().GroupVersionKind()
      if len(objGVK.Version) == 0 {
        return c.encoder.Encode(obj, w)
      }
      targetGVK, ok := c.encodeVersion.KindForGroupVersionKinds([]schema.GroupVersionKind{objGVK})
      if !ok {
        return runtime.NewNotRegisteredGVKErrForTarget(c.originalSchemeName, objGVK, c.encodeVersion)
      }
      if targetGVK == objGVK {
        return c.encoder.Encode(obj, w)
      }
    }
  }


  gvks, isUnversioned, err := c.typer.ObjectKinds(obj)
  if err != nil {
    return err
  }


  objectKind := obj.GetObjectKind()
  old := objectKind.GroupVersionKind()
  // restore the old GVK after encoding
  defer objectKind.SetGroupVersionKind(old)


  if c.encodeVersion == nil || isUnversioned {
    if e, ok := obj.(runtime.NestedObjectEncoder); ok {
      if err := e.EncodeNestedObjects(runtime.WithVersionEncoder{Encoder: c.encoder, ObjectTyper: c.typer}); err != nil {
        return err
      }
    }
    objectKind.SetGroupVersionKind(gvks[0])
    return c.encoder.Encode(obj, w)
  }


  // Perform a conversion if necessary
  out, err := c.convertor.ConvertToVersion(obj, c.encodeVersion)
  if err != nil {
    return err
  }


  if e, ok := out.(runtime.NestedObjectEncoder); ok {
    if err := e.EncodeNestedObjects(runtime.WithVersionEncoder{Version: c.encodeVersion, Encoder: c.encoder, ObjectTyper: c.typer}); err != nil {
      return err
    }
  }


  // Conversion is responsible for setting the proper group, version, and kind onto the outgoing object
  return c.encoder.Encode(out, w)
}