Schema

代码位置：k8s.io/apimachinery/pkg/runtime

Object

Overview

Encoder/Decoder

Scheme

Overview

关键方法

New

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)
}

ObjectKinds

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
}

Converter

Overview

ConversionFuncs

结构定义

type ConversionFuncs struct {
    fns     map[typePair]reflect.Value
    untyped map[typePair]ConversionFunc
}

Add

func (c ConversionFuncs) Add(fns ...interface{}) error {
    for _, fn := range fns {
        fv := reflect.ValueOf(fn)
        ft := fv.Type()
        if err := verifyConversionFunctionSignature(ft); err != nil {
            return err
        }
        c.fns[typePair{ft.In(0).Elem(), ft.In(1).Elem()}] = fv
    }
    return nil
}

AddUntyped

func (c ConversionFuncs) AddUntyped(a, b interface{}, fn ConversionFunc) error {
    tA, tB := reflect.TypeOf(a), reflect.TypeOf(b)
    if tA.Kind() != reflect.Ptr {
        return fmt.Errorf("the type %T must be a pointer to register as an untyped conversion", a)
    }
    if tB.Kind() != reflect.Ptr {
        return fmt.Errorf("the type %T must be a pointer to register as an untyped conversion", b)
    }
    c.untyped[typePair{tA, tB}] = fn
    return nil
}