make register.GroupVersion use GroupVersion

pkg/api/install/install.go

@@ -30,7 +30,6 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/meta"
 	"k8s.io/kubernetes/pkg/api/registered"
-	apiutil "k8s.io/kubernetes/pkg/api/util"
 	"k8s.io/kubernetes/pkg/api/v1"
 	"k8s.io/kubernetes/pkg/runtime"
 )
@@ -52,16 +51,16 @@ func init() {
 	registeredGroupVersions := registered.GroupVersionsForGroup("")
 	groupVersion := registeredGroupVersions[0]
 	*groupMeta = latest.GroupMeta{
-		GroupVersion: groupVersion,
-		Group:        apiutil.GetGroup(groupVersion),
-		Version:      apiutil.GetVersion(groupVersion),
-		Codec:        runtime.CodecFor(api.Scheme, groupVersion),
+		GroupVersion: groupVersion.String(),
+		Group:        groupVersion.Group,
+		Version:      groupVersion.Version,
+		Codec:        runtime.CodecFor(api.Scheme, groupVersion.String()),
 	}
 	var versions []string
 	var groupVersions []string
 	for i := len(registeredGroupVersions) - 1; i >= 0; i-- {
-		versions = append(versions, apiutil.GetVersion(registeredGroupVersions[i]))
-		groupVersions = append(groupVersions, registeredGroupVersions[i])
+		versions = append(versions, registeredGroupVersions[i].Version)
+		groupVersions = append(groupVersions, registeredGroupVersions[i].String())
 	}
 	groupMeta.Versions = versions
 	groupMeta.GroupVersions = groupVersions

pkg/api/registered/registered.go

@@ -22,46 +22,60 @@ import (
 	"strings"
 
 	"github.com/golang/glog"
-	apiutil "k8s.io/kubernetes/pkg/api/util"
+	"k8s.io/kubernetes/pkg/api/unversioned"
 )
 
 // List of registered API versions.
 // The list is in the order of most preferred to the least.
-var RegisteredVersions []string
+var RegisteredGroupVersions []unversioned.GroupVersion
 
 func init() {
-	validGroupVersions := map[string]bool{
-		"v1":                       true,
-		"extensions/v1beta1":       true,
-		"componentconfig/v1alpha1": true,
-		"metrics/v1alpha1":         true,
+	validGroupVersions := map[unversioned.GroupVersion]bool{
+		unversioned.GroupVersion{Group: "", Version: "v1"}:                      true,
+		unversioned.GroupVersion{Group: "extensions", Version: "v1beta1"}:       true,
+		unversioned.GroupVersion{Group: "componentconfig", Version: "v1alpha1"}: true,
+		unversioned.GroupVersion{Group: "metrics", Version: "v1alpha1"}:         true,
 	}
 
 	// The default list of supported api versions, in order of most preferred to the least.
-	defaultSupportedVersions := "v1,extensions/v1beta1,componentconfig/v1alpha1"
+	supportedVersions := []unversioned.GroupVersion{
+		{Group: "", Version: "v1"},
+		{Group: "extensions", Version: "v1beta1"},
+		{Group: "componentconfig", Version: "v1alpha1"},
+	}
+
 	// Env var KUBE_API_VERSIONS is a comma separated list of API versions that should be registered in the scheme.
 	// The versions should be in the order of most preferred to the least.
-	supportedVersions := os.Getenv("KUBE_API_VERSIONS")
-	if supportedVersions == "" {
-		supportedVersions = defaultSupportedVersions
-	}
-	versions := strings.Split(supportedVersions, ",")
-	for _, version := range versions {
-		// Verify that the version is valid.
-		valid, ok := validGroupVersions[version]
-		if !ok || !valid {
-			// Not a valid API version.
-			glog.Fatalf("invalid api version: %s in KUBE_API_VERSIONS: %s. List of valid API versions: %v",
-				version, os.Getenv("KUBE_API_VERSIONS"), validGroupVersions)
+	userRequestedVersions := os.Getenv("KUBE_API_VERSIONS")
+	if len(userRequestedVersions) != 0 {
+		// reset the supported versions
+		supportedVersions = []unversioned.GroupVersion{}
+		for _, version := range strings.Split(userRequestedVersions, ",") {
+			gv, err := unversioned.ParseGroupVersion(version)
+			if err != nil {
+				glog.Fatalf("invalid api version: %s in KUBE_API_VERSIONS: %s. List of valid API versions: %v",
+					version, os.Getenv("KUBE_API_VERSIONS"), validGroupVersions)
+			}
+
+			// Verify that the version is valid.
+			valid, ok := validGroupVersions[gv]
+			if !ok || !valid {
+				// Not a valid API version.
+				glog.Fatalf("invalid api version: %s in KUBE_API_VERSIONS: %s. List of valid API versions: %v",
+					version, os.Getenv("KUBE_API_VERSIONS"), validGroupVersions)
+			}
+
+			supportedVersions = append(supportedVersions, gv)
 		}
-		RegisteredVersions = append(RegisteredVersions, version)
 	}
+
+	RegisteredGroupVersions = supportedVersions
 }
 
 // Returns true if the given api version is one of the registered api versions.
-func IsRegisteredAPIVersion(version string) bool {
-	for _, apiVersion := range RegisteredVersions {
-		if apiVersion == version {
+func IsRegisteredAPIGroupVersion(gv unversioned.GroupVersion) bool {
+	for _, currGV := range RegisteredGroupVersions {
+		if currGV == gv {
 			return true
 		}
 	}
@@ -70,10 +84,10 @@ func IsRegisteredAPIVersion(version string) bool {
 
 // GroupVersionsForGroup returns the registered versions of a group in the form
 // of "group/version".
-func GroupVersionsForGroup(group string) []string {
-	ret := []string{}
-	for _, v := range RegisteredVersions {
-		if apiutil.GetGroup(v) == group {
+func GroupVersionsForGroup(group string) []unversioned.GroupVersion {
+	ret := []unversioned.GroupVersion{}
+	for _, v := range RegisteredGroupVersions {
+		if v.Group == group {
 			ret = append(ret, v)
 		}
 	}

pkg/api/testing/fuzzer.go

@@ -284,9 +284,9 @@ func FuzzerFor(t *testing.T, version string, src rand.Source) *fuzz.Fuzzer {
 				ev.ValueFrom = &api.EnvVarSource{}
 				ev.ValueFrom.FieldRef = &api.ObjectFieldSelector{}
 
-				versions := registered.RegisteredVersions
+				versions := registered.RegisteredGroupVersions
 
-				ev.ValueFrom.FieldRef.APIVersion = versions[c.Rand.Intn(len(versions))]
+				ev.ValueFrom.FieldRef.APIVersion = versions[c.Rand.Intn(len(versions))].String()
 				ev.ValueFrom.FieldRef.FieldPath = c.RandString()
 			}
 		},

pkg/api/v1/register.go

@@ -28,7 +28,7 @@ var Codec = runtime.CodecFor(api.Scheme, "v1")
 
 func init() {
 	// Check if v1 is in the list of supported API versions.
-	if !registered.IsRegisteredAPIVersion("v1") {
+	if !registered.IsRegisteredAPIGroupVersion(unversioned.GroupVersion{Group: "", Version: "v1"}) {
 		return
 	}
 

pkg/apis/componentconfig/install/install.go

@@ -28,7 +28,6 @@ import (
 	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/meta"
 	"k8s.io/kubernetes/pkg/api/registered"
-	apiutil "k8s.io/kubernetes/pkg/api/util"
 	_ "k8s.io/kubernetes/pkg/apis/componentconfig"
 	"k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -48,16 +47,16 @@ func init() {
 	registeredGroupVersions := registered.GroupVersionsForGroup("componentconfig")
 	groupVersion := registeredGroupVersions[0]
 	*groupMeta = latest.GroupMeta{
-		GroupVersion: groupVersion,
-		Group:        apiutil.GetGroup(groupVersion),
-		Version:      apiutil.GetVersion(groupVersion),
-		Codec:        runtime.CodecFor(api.Scheme, groupVersion),
+		GroupVersion: groupVersion.String(),
+		Group:        groupVersion.Group,
+		Version:      groupVersion.Version,
+		Codec:        runtime.CodecFor(api.Scheme, groupVersion.String()),
 	}
 	var versions []string
 	var groupVersions []string
 	for i := len(registeredGroupVersions) - 1; i >= 0; i-- {
-		versions = append(versions, apiutil.GetVersion(registeredGroupVersions[i]))
-		groupVersions = append(groupVersions, registeredGroupVersions[i])
+		versions = append(versions, registeredGroupVersions[i].Version)
+		groupVersions = append(groupVersions, registeredGroupVersions[i].String())
 	}
 	groupMeta.Versions = versions
 	groupMeta.GroupVersions = groupVersions

pkg/apis/extensions/install/install.go

@@ -28,7 +28,6 @@ import (
 	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/meta"
 	"k8s.io/kubernetes/pkg/api/registered"
-	apiutil "k8s.io/kubernetes/pkg/api/util"
 	_ "k8s.io/kubernetes/pkg/apis/extensions"
 	"k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -48,16 +47,16 @@ func init() {
 	registeredGroupVersions := registered.GroupVersionsForGroup("extensions")
 	groupVersion := registeredGroupVersions[0]
 	*groupMeta = latest.GroupMeta{
-		GroupVersion: groupVersion,
-		Group:        apiutil.GetGroup(groupVersion),
-		Version:      apiutil.GetVersion(groupVersion),
-		Codec:        runtime.CodecFor(api.Scheme, groupVersion),
+		GroupVersion: groupVersion.String(),
+		Group:        groupVersion.Group,
+		Version:      groupVersion.Version,
+		Codec:        runtime.CodecFor(api.Scheme, groupVersion.String()),
 	}
 	var versions []string
 	var groupVersions []string
 	for i := len(registeredGroupVersions) - 1; i >= 0; i-- {
-		versions = append(versions, apiutil.GetVersion(registeredGroupVersions[i]))
-		groupVersions = append(groupVersions, registeredGroupVersions[i])
+		versions = append(versions, registeredGroupVersions[i].Version)
+		groupVersions = append(groupVersions, registeredGroupVersions[i].String())
 	}
 	groupMeta.Versions = versions
 	groupMeta.GroupVersions = groupVersions

pkg/apis/metrics/install/install.go

@@ -28,7 +28,6 @@ import (
 	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/meta"
 	"k8s.io/kubernetes/pkg/api/registered"
-	apiutil "k8s.io/kubernetes/pkg/api/util"
 	_ "k8s.io/kubernetes/pkg/apis/metrics"
 	"k8s.io/kubernetes/pkg/apis/metrics/v1alpha1"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -48,16 +47,16 @@ func init() {
 	registeredGroupVersions := registered.GroupVersionsForGroup("metrics")
 	groupVersion := registeredGroupVersions[0]
 	*groupMeta = latest.GroupMeta{
-		GroupVersion: groupVersion,
-		Group:        apiutil.GetGroup(groupVersion),
-		Version:      apiutil.GetVersion(groupVersion),
-		Codec:        runtime.CodecFor(api.Scheme, groupVersion),
+		GroupVersion: groupVersion.String(),
+		Group:        groupVersion.Group,
+		Version:      groupVersion.Version,
+		Codec:        runtime.CodecFor(api.Scheme, groupVersion.String()),
 	}
 	var versions []string
 	var groupVersions []string
 	for i := len(registeredGroupVersions) - 1; i >= 0; i-- {
-		versions = append(versions, apiutil.GetVersion(registeredGroupVersions[i]))
-		groupVersions = append(groupVersions, registeredGroupVersions[i])
+		versions = append(versions, registeredGroupVersions[i].Version)
+		groupVersions = append(groupVersions, registeredGroupVersions[i].String())
 	}
 	groupMeta.Versions = versions
 	groupMeta.GroupVersions = groupVersions

pkg/client/unversioned/testclient/testclient.go

@@ -294,7 +294,11 @@ func (c *Fake) ServerAPIVersions() (*unversioned.APIVersions, error) {
 	action.Resource = "apiversions"
 
 	c.Invokes(action, nil)
-	return &unversioned.APIVersions{Versions: registered.RegisteredVersions}, nil
+	gvStrings := []string{}
+	for _, gv := range registered.RegisteredGroupVersions {
+		gvStrings = append(gvStrings, gv.String())
+	}
+	return &unversioned.APIVersions{Versions: gvStrings}, nil
 }
 
 func (c *Fake) ComponentStatuses() client.ComponentStatusInterface {

pkg/kubectl/cmd/convert.go

@@ -22,6 +22,7 @@ import (
 
 	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/registered"
+	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/kubectl"
 	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
 	"k8s.io/kubernetes/pkg/kubectl/resource"
@@ -95,7 +96,11 @@ type ConvertOptions struct {
 // Complete collects information required to run Convert command from command line.
 func (o *ConvertOptions) Complete(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string) (err error) {
 	o.outputVersion = cmdutil.OutputVersion(cmd, latest.GroupOrDie("").Version)
-	if !registered.IsRegisteredAPIVersion(o.outputVersion) {
+	outputGV, err := unversioned.ParseGroupVersion(o.outputVersion)
+	if err != nil {
+		return fmt.Errorf("unable to parse group/version from %q: %v", o.outputVersion, err)
+	}
+	if !registered.IsRegisteredAPIGroupVersion(outputGV) {
 		cmdutil.UsageError(cmd, "'%s' is not a registered version.", o.outputVersion)
 	}
 

pkg/kubectl/cmd/util/clientcache.go

@@ -71,16 +71,8 @@ func (c *ClientCache) ClientConfigForVersion(version string) (*client.Config, er
 		}
 		preferredGV = &gv
 	}
-	registeredGVs := []unversioned.GroupVersion{}
-	for _, gvString := range registered.RegisteredVersions {
-		gv, err := unversioned.ParseGroupVersion(gvString)
-		if err != nil {
-			return nil, err
-		}
-		registeredGVs = append(registeredGVs, gv)
-	}
 
-	negotiatedVersion, err := client.NegotiateVersion(c.defaultClient, &config, preferredGV, registeredGVs)
+	negotiatedVersion, err := client.NegotiateVersion(c.defaultClient, &config, preferredGV, registered.RegisteredGroupVersions)
 	if err != nil {
 		return nil, err
 	}

pkg/kubectl/cmd/util/factory.go

@@ -35,6 +35,7 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/meta"
 	"k8s.io/kubernetes/pkg/api/registered"
+	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/api/validation"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
@@ -476,8 +477,12 @@ func (c *clientSwaggerSchema) ValidateBytes(data []byte) error {
 	if err != nil {
 		return err
 	}
-	if ok := registered.IsRegisteredAPIVersion(version); !ok {
-		return fmt.Errorf("API version %q isn't supported, only supports API versions %q", version, registered.RegisteredVersions)
+	gv, err := unversioned.ParseGroupVersion(version)
+	if err != nil {
+		return fmt.Errorf("unable to parse group/version from %q: %v", version, err)
+	}
+	if ok := registered.IsRegisteredAPIGroupVersion(gv); !ok {
+		return fmt.Errorf("API version %q isn't supported, only supports API versions %q", version, registered.RegisteredGroupVersions)
 	}
 	resource, _ := meta.KindToResource(kind, false)
 	group, err := c.mapper.GroupForResource(resource)

pkg/kubectl/resource/mapper.go

@@ -23,6 +23,7 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/meta"
 	"k8s.io/kubernetes/pkg/api/registered"
+	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util/yaml"
 )
@@ -48,8 +49,12 @@ func (m *Mapper) InfoForData(data []byte, source string) (*Info, error) {
 	if err != nil {
 		return nil, fmt.Errorf("unable to get type info from %q: %v", source, err)
 	}
-	if ok := registered.IsRegisteredAPIVersion(version); !ok {
-		return nil, fmt.Errorf("API version %q in %q isn't supported, only supports API versions %q", version, source, registered.RegisteredVersions)
+	gv, err := unversioned.ParseGroupVersion(version)
+	if err != nil {
+		return nil, fmt.Errorf("unable to parse group/version from %q: %v", version, err)
+	}
+	if ok := registered.IsRegisteredAPIGroupVersion(gv); !ok {
+		return nil, fmt.Errorf("API version %q in %q isn't supported, only supports API versions %q", version, source, registered.RegisteredGroupVersions)
 	}
 	if kind == "" {
 		return nil, fmt.Errorf("kind not set in %q", source)

pkg/kubelet/config/common_test.go

@@ -71,8 +71,8 @@ func TestDecodeSinglePod(t *testing.T) {
 		t.Errorf("expected:\n%#v\ngot:\n%#v\n%s", pod, podOut, string(json))
 	}
 
-	for _, version := range registered.GroupVersionsForGroup("") {
-		externalPod, err := testapi.Default.Converter().ConvertToVersion(pod, version)
+	for _, gv := range registered.GroupVersionsForGroup("") {
+		externalPod, err := testapi.Default.Converter().ConvertToVersion(pod, gv.String())
 		if err != nil {
 			t.Errorf("unexpected error: %v", err)
 		}
@@ -137,8 +137,8 @@ func TestDecodePodList(t *testing.T) {
 		t.Errorf("expected:\n%#v\ngot:\n%#v\n%s", podList, &podListOut, string(json))
 	}
 
-	for _, version := range registered.GroupVersionsForGroup("") {
-		externalPodList, err := testapi.Default.Converter().ConvertToVersion(podList, version)
+	for _, gv := range registered.GroupVersionsForGroup("") {
+		externalPodList, err := testapi.Default.Converter().ConvertToVersion(podList, gv.String())
 		if err != nil {
 			t.Errorf("unexpected error: %v", err)
 		}