func init() { kubeTestAPI := os.Getenv("KUBE_TEST_API") if len(kubeTestAPI) != 0 { testGroupVersions := strings.Split(kubeTestAPI, ",") for _, gvString := range testGroupVersions { groupVersion, err := unversioned.ParseGroupVersion(gvString) if err != nil { panic(fmt.Sprintf("Error parsing groupversion %v: %v", gvString, err)) } Groups[groupVersion.Group] = TestGroup{ externalGroupVersion: groupVersion, internalGroupVersion: unversioned.GroupVersion{Group: groupVersion.Group, Version: runtime.APIVersionInternal}, } } } if _, ok := Groups[api.GroupName]; !ok { Groups[api.GroupName] = TestGroup{ externalGroupVersion: unversioned.GroupVersion{Group: api.GroupName, Version: registered.GroupOrDie(api.GroupName).GroupVersion.Version}, internalGroupVersion: api.SchemeGroupVersion, } } if _, ok := Groups[extensions.GroupName]; !ok { Groups[extensions.GroupName] = TestGroup{ externalGroupVersion: unversioned.GroupVersion{Group: extensions.GroupName, Version: registered.GroupOrDie(extensions.GroupName).GroupVersion.Version}, internalGroupVersion: extensions.SchemeGroupVersion, } } Default = Groups[api.GroupName] Extensions = Groups[extensions.GroupName] }
func (obj objectAccessor) SetAPIVersion(version string) { gvk := obj.GetObjectKind().GroupVersionKind() if gvk == nil { gvk = &unversioned.GroupVersionKind{} } gv, err := unversioned.ParseGroupVersion(version) if err != nil { gv = unversioned.GroupVersion{Version: version} } gvk.Group, gvk.Version = gv.Group, gv.Version obj.GetObjectKind().SetGroupVersionKind(gvk) }
// ConvertToVersion attempts to convert an input object to its matching Kind in another // version within this scheme. Will return an error if the provided version does not // contain the inKind (or a mapping by name defined with AddKnownTypeWithName). Will also // return an error if the conversion does not result in a valid Object being // returned. The serializer handles loading/serializing nested objects. func (s *Scheme) ConvertToVersion(in Object, outVersion string) (Object, error) { gv, err := unversioned.ParseGroupVersion(outVersion) if err != nil { return nil, err } switch in.(type) { case *Unknown, *Unstructured: old := in.GetObjectKind().GroupVersionKind() defer in.GetObjectKind().SetGroupVersionKind(old) setTargetVersion(in, s, gv) return in, nil } t := reflect.TypeOf(in) if t.Kind() != reflect.Ptr { return nil, fmt.Errorf("only pointer types may be converted: %v", t) } t = t.Elem() if t.Kind() != reflect.Struct { return nil, fmt.Errorf("only pointers to struct types may be converted: %v", t) } var kind unversioned.GroupVersionKind if unversionedKind, ok := s.unversionedTypes[t]; ok { kind = unversionedKind } else { kinds, ok := s.typeToGVK[t] if !ok || len(kinds) == 0 { return nil, fmt.Errorf("%v is not a registered type and cannot be converted into version %q", t, outVersion) } kind = kinds[0] } outKind := gv.WithKind(kind.Kind) inKind, err := s.ObjectKind(in) if err != nil { return nil, err } out, err := s.New(outKind) if err != nil { return nil, err } flags, meta := s.generateConvertMeta(inKind.GroupVersion(), gv, in) if err := s.converter.Convert(in, out, flags, meta); err != nil { return nil, err } setTargetVersion(out, s, gv) return out, nil }
// Interpret will return the APIVersion and Kind of the JSON wire-format // encoding of an object, or an error. func (SimpleMetaFactory) Interpret(data []byte) (*unversioned.GroupVersionKind, error) { findKind := struct { APIVersion string `json:"apiVersion,omitempty"` Kind string `json:"kind,omitempty"` }{} if err := json.Unmarshal(data, &findKind); err != nil { return nil, fmt.Errorf("couldn't get version/kind; json parse error: %v", err) } gv, err := unversioned.ParseGroupVersion(findKind.APIVersion) if err != nil { return nil, err } return &unversioned.GroupVersionKind{Group: gv.Group, Version: gv.Version, Kind: findKind.Kind}, nil }
func init() { // Env var KUBE_API_VERSIONS is a comma separated list of API versions that // should be registered in the scheme. kubeAPIVersions := os.Getenv("KUBE_API_VERSIONS") if len(kubeAPIVersions) != 0 { for _, version := range strings.Split(kubeAPIVersions, ",") { gv, err := unversioned.ParseGroupVersion(version) if err != nil { glog.Fatalf("invalid api version: %s in KUBE_API_VERSIONS: %s.", version, os.Getenv("KUBE_API_VERSIONS")) } envRequestedVersions[gv] = struct{}{} } } }
func (testMetaFactory) Interpret(data []byte) (*unversioned.GroupVersionKind, error) { findKind := struct { APIVersion string `json:"myVersionKey,omitempty"` ObjectKind string `json:"myKindKey,omitempty"` }{} // yaml is a superset of json, so we use it to decode here. That way, // we understand both. if err := yaml.Unmarshal(data, &findKind); err != nil { return nil, fmt.Errorf("couldn't get version/kind: %v", err) } gv, err := unversioned.ParseGroupVersion(findKind.APIVersion) if err != nil { return nil, err } return &unversioned.GroupVersionKind{Group: gv.Group, Version: gv.Version, Kind: findKind.ObjectKind}, nil }