301 lines
10 KiB
Go
301 lines
10 KiB
Go
/*
|
|
Copyright 2015 The Kubernetes Authors.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package schema
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
// ParseResourceArg takes the common style of string which may be either `resource.group.com` or `resource.version.group.com`
|
|
// and parses it out into both possibilities. This code takes no responsibility for knowing which representation was intended
|
|
// but with a knowledge of all GroupVersions, calling code can take a very good guess. If there are only two segments, then
|
|
// `*GroupVersionResource` is nil.
|
|
// `resource.group.com` -> `group=com, version=group, resource=resource` and `group=group.com, resource=resource`
|
|
func ParseResourceArg(arg string) (*GroupVersionResource, GroupResource) {
|
|
var gvr *GroupVersionResource
|
|
if strings.Count(arg, ".") >= 2 {
|
|
s := strings.SplitN(arg, ".", 3)
|
|
gvr = &GroupVersionResource{Group: s[2], Version: s[1], Resource: s[0]}
|
|
}
|
|
|
|
return gvr, ParseGroupResource(arg)
|
|
}
|
|
|
|
// ParseKindArg takes the common style of string which may be either `Kind.group.com` or `Kind.version.group.com`
|
|
// and parses it out into both possibilities. This code takes no responsibility for knowing which representation was intended
|
|
// but with a knowledge of all GroupKinds, calling code can take a very good guess. If there are only two segments, then
|
|
// `*GroupVersionResource` is nil.
|
|
// `Kind.group.com` -> `group=com, version=group, kind=Kind` and `group=group.com, kind=Kind`
|
|
func ParseKindArg(arg string) (*GroupVersionKind, GroupKind) {
|
|
var gvk *GroupVersionKind
|
|
if strings.Count(arg, ".") >= 2 {
|
|
s := strings.SplitN(arg, ".", 3)
|
|
gvk = &GroupVersionKind{Group: s[2], Version: s[1], Kind: s[0]}
|
|
}
|
|
|
|
return gvk, ParseGroupKind(arg)
|
|
}
|
|
|
|
// GroupResource specifies a Group and a Resource, but does not force a version. This is useful for identifying
|
|
// concepts during lookup stages without having partially valid types
|
|
type GroupResource struct {
|
|
Group string
|
|
Resource string
|
|
}
|
|
|
|
func (gr GroupResource) WithVersion(version string) GroupVersionResource {
|
|
return GroupVersionResource{Group: gr.Group, Version: version, Resource: gr.Resource}
|
|
}
|
|
|
|
func (gr GroupResource) Empty() bool {
|
|
return len(gr.Group) == 0 && len(gr.Resource) == 0
|
|
}
|
|
|
|
func (gr GroupResource) String() string {
|
|
if len(gr.Group) == 0 {
|
|
return gr.Resource
|
|
}
|
|
return gr.Resource + "." + gr.Group
|
|
}
|
|
|
|
func ParseGroupKind(gk string) GroupKind {
|
|
i := strings.Index(gk, ".")
|
|
if i == -1 {
|
|
return GroupKind{Kind: gk}
|
|
}
|
|
|
|
return GroupKind{Group: gk[i+1:], Kind: gk[:i]}
|
|
}
|
|
|
|
// ParseGroupResource turns "resource.group" string into a GroupResource struct. Empty strings are allowed
|
|
// for each field.
|
|
func ParseGroupResource(gr string) GroupResource {
|
|
if i := strings.Index(gr, "."); i >= 0 {
|
|
return GroupResource{Group: gr[i+1:], Resource: gr[:i]}
|
|
}
|
|
return GroupResource{Resource: gr}
|
|
}
|
|
|
|
// GroupVersionResource unambiguously identifies a resource. It doesn't anonymously include GroupVersion
|
|
// to avoid automatic coercion. It doesn't use a GroupVersion to avoid custom marshalling
|
|
type GroupVersionResource struct {
|
|
Group string
|
|
Version string
|
|
Resource string
|
|
}
|
|
|
|
func (gvr GroupVersionResource) Empty() bool {
|
|
return len(gvr.Group) == 0 && len(gvr.Version) == 0 && len(gvr.Resource) == 0
|
|
}
|
|
|
|
func (gvr GroupVersionResource) GroupResource() GroupResource {
|
|
return GroupResource{Group: gvr.Group, Resource: gvr.Resource}
|
|
}
|
|
|
|
func (gvr GroupVersionResource) GroupVersion() GroupVersion {
|
|
return GroupVersion{Group: gvr.Group, Version: gvr.Version}
|
|
}
|
|
|
|
func (gvr GroupVersionResource) String() string {
|
|
return strings.Join([]string{gvr.Group, "/", gvr.Version, ", Resource=", gvr.Resource}, "")
|
|
}
|
|
|
|
// GroupKind specifies a Group and a Kind, but does not force a version. This is useful for identifying
|
|
// concepts during lookup stages without having partially valid types
|
|
type GroupKind struct {
|
|
Group string
|
|
Kind string
|
|
}
|
|
|
|
func (gk GroupKind) Empty() bool {
|
|
return len(gk.Group) == 0 && len(gk.Kind) == 0
|
|
}
|
|
|
|
func (gk GroupKind) WithVersion(version string) GroupVersionKind {
|
|
return GroupVersionKind{Group: gk.Group, Version: version, Kind: gk.Kind}
|
|
}
|
|
|
|
func (gk GroupKind) String() string {
|
|
if len(gk.Group) == 0 {
|
|
return gk.Kind
|
|
}
|
|
return gk.Kind + "." + gk.Group
|
|
}
|
|
|
|
// GroupVersionKind unambiguously identifies a kind. It doesn't anonymously include GroupVersion
|
|
// to avoid automatic coercion. It doesn't use a GroupVersion to avoid custom marshalling
|
|
type GroupVersionKind struct {
|
|
Group string
|
|
Version string
|
|
Kind string
|
|
}
|
|
|
|
// Empty returns true if group, version, and kind are empty
|
|
func (gvk GroupVersionKind) Empty() bool {
|
|
return len(gvk.Group) == 0 && len(gvk.Version) == 0 && len(gvk.Kind) == 0
|
|
}
|
|
|
|
func (gvk GroupVersionKind) GroupKind() GroupKind {
|
|
return GroupKind{Group: gvk.Group, Kind: gvk.Kind}
|
|
}
|
|
|
|
func (gvk GroupVersionKind) GroupVersion() GroupVersion {
|
|
return GroupVersion{Group: gvk.Group, Version: gvk.Version}
|
|
}
|
|
|
|
func (gvk GroupVersionKind) String() string {
|
|
return gvk.Group + "/" + gvk.Version + ", Kind=" + gvk.Kind
|
|
}
|
|
|
|
// GroupVersion contains the "group" and the "version", which uniquely identifies the API.
|
|
type GroupVersion struct {
|
|
Group string
|
|
Version string
|
|
}
|
|
|
|
// Empty returns true if group and version are empty
|
|
func (gv GroupVersion) Empty() bool {
|
|
return len(gv.Group) == 0 && len(gv.Version) == 0
|
|
}
|
|
|
|
// String puts "group" and "version" into a single "group/version" string. For the legacy v1
|
|
// it returns "v1".
|
|
func (gv GroupVersion) String() string {
|
|
// special case the internal apiVersion for the legacy kube types
|
|
if gv.Empty() {
|
|
return ""
|
|
}
|
|
|
|
// special case of "v1" for backward compatibility
|
|
if len(gv.Group) == 0 && gv.Version == "v1" {
|
|
return gv.Version
|
|
}
|
|
if len(gv.Group) > 0 {
|
|
return gv.Group + "/" + gv.Version
|
|
}
|
|
return gv.Version
|
|
}
|
|
|
|
// KindForGroupVersionKinds identifies the preferred GroupVersionKind out of a list. It returns ok false
|
|
// if none of the options match the group. It prefers a match to group and version over just group.
|
|
// TODO: Move GroupVersion to a package under pkg/runtime, since it's used by scheme.
|
|
// TODO: Introduce an adapter type between GroupVersion and runtime.GroupVersioner, and use LegacyCodec(GroupVersion)
|
|
// in fewer places.
|
|
func (gv GroupVersion) KindForGroupVersionKinds(kinds []GroupVersionKind) (target GroupVersionKind, ok bool) {
|
|
for _, gvk := range kinds {
|
|
if gvk.Group == gv.Group && gvk.Version == gv.Version {
|
|
return gvk, true
|
|
}
|
|
}
|
|
for _, gvk := range kinds {
|
|
if gvk.Group == gv.Group {
|
|
return gv.WithKind(gvk.Kind), true
|
|
}
|
|
}
|
|
return GroupVersionKind{}, false
|
|
}
|
|
|
|
// ParseGroupVersion turns "group/version" string into a GroupVersion struct. It reports error
|
|
// if it cannot parse the string.
|
|
func ParseGroupVersion(gv string) (GroupVersion, error) {
|
|
// this can be the internal version for the legacy kube types
|
|
// TODO once we've cleared the last uses as strings, this special case should be removed.
|
|
if (len(gv) == 0) || (gv == "/") {
|
|
return GroupVersion{}, nil
|
|
}
|
|
|
|
switch strings.Count(gv, "/") {
|
|
case 0:
|
|
return GroupVersion{"", gv}, nil
|
|
case 1:
|
|
i := strings.Index(gv, "/")
|
|
return GroupVersion{gv[:i], gv[i+1:]}, nil
|
|
default:
|
|
return GroupVersion{}, fmt.Errorf("unexpected GroupVersion string: %v", gv)
|
|
}
|
|
}
|
|
|
|
// WithKind creates a GroupVersionKind based on the method receiver's GroupVersion and the passed Kind.
|
|
func (gv GroupVersion) WithKind(kind string) GroupVersionKind {
|
|
return GroupVersionKind{Group: gv.Group, Version: gv.Version, Kind: kind}
|
|
}
|
|
|
|
// WithResource creates a GroupVersionResource based on the method receiver's GroupVersion and the passed Resource.
|
|
func (gv GroupVersion) WithResource(resource string) GroupVersionResource {
|
|
return GroupVersionResource{Group: gv.Group, Version: gv.Version, Resource: resource}
|
|
}
|
|
|
|
// GroupVersions can be used to represent a set of desired group versions.
|
|
// TODO: Move GroupVersions to a package under pkg/runtime, since it's used by scheme.
|
|
// TODO: Introduce an adapter type between GroupVersions and runtime.GroupVersioner, and use LegacyCodec(GroupVersion)
|
|
// in fewer places.
|
|
type GroupVersions []GroupVersion
|
|
|
|
// KindForGroupVersionKinds identifies the preferred GroupVersionKind out of a list. It returns ok false
|
|
// if none of the options match the group.
|
|
func (gvs GroupVersions) KindForGroupVersionKinds(kinds []GroupVersionKind) (GroupVersionKind, bool) {
|
|
var targets []GroupVersionKind
|
|
for _, gv := range gvs {
|
|
target, ok := gv.KindForGroupVersionKinds(kinds)
|
|
if !ok {
|
|
continue
|
|
}
|
|
targets = append(targets, target)
|
|
}
|
|
if len(targets) == 1 {
|
|
return targets[0], true
|
|
}
|
|
if len(targets) > 1 {
|
|
return bestMatch(kinds, targets), true
|
|
}
|
|
return GroupVersionKind{}, false
|
|
}
|
|
|
|
// bestMatch tries to pick best matching GroupVersionKind and falls back to the first
|
|
// found if no exact match exists.
|
|
func bestMatch(kinds []GroupVersionKind, targets []GroupVersionKind) GroupVersionKind {
|
|
for _, gvk := range targets {
|
|
for _, k := range kinds {
|
|
if k == gvk {
|
|
return k
|
|
}
|
|
}
|
|
}
|
|
return targets[0]
|
|
}
|
|
|
|
// ToAPIVersionAndKind is a convenience method for satisfying runtime.Object on types that
|
|
// do not use TypeMeta.
|
|
func (gvk GroupVersionKind) ToAPIVersionAndKind() (string, string) {
|
|
if gvk.Empty() {
|
|
return "", ""
|
|
}
|
|
return gvk.GroupVersion().String(), gvk.Kind
|
|
}
|
|
|
|
// FromAPIVersionAndKind returns a GVK representing the provided fields for types that
|
|
// do not use TypeMeta. This method exists to support test types and legacy serializations
|
|
// that have a distinct group and kind.
|
|
// TODO: further reduce usage of this method.
|
|
func FromAPIVersionAndKind(apiVersion, kind string) GroupVersionKind {
|
|
if gv, err := ParseGroupVersion(apiVersion); err == nil {
|
|
return GroupVersionKind{Group: gv.Group, Version: gv.Version, Kind: kind}
|
|
}
|
|
return GroupVersionKind{Kind: kind}
|
|
}
|