use groupversion in RESTMapping

pkg/api/install/install_test.go

@@ -78,12 +78,16 @@ func TestRESTMapper(t *testing.T) {
 		t.Errorf("unexpected version mapping: %s %s %v", v, k, err)
 	}
 
-	if m, err := latest.GroupOrDie("").RESTMapper.RESTMapping("PodTemplate", ""); err != nil || m.APIVersion != "v1" || m.Resource != "podtemplates" {
+	expectedGroupVersion := unversioned.GroupVersion{Version: "v1"}
+
+	if m, err := latest.GroupOrDie("").RESTMapper.RESTMapping("PodTemplate", ""); err != nil || m.GroupVersionKind.GroupVersion() != expectedGroupVersion || m.Resource != "podtemplates" {
 		t.Errorf("unexpected version mapping: %#v %v", m, err)
 	}
 
 	for _, version := range latest.GroupOrDie("").Versions {
-		mapping, err := latest.GroupOrDie("").RESTMapper.RESTMapping("ReplicationController", version)
+		currGroupVersion := unversioned.GroupVersion{Version: version}
+
+		mapping, err := latest.GroupOrDie("").RESTMapper.RESTMapping("ReplicationController", currGroupVersion.String())
 		if err != nil {
 			t.Errorf("unexpected error: %v", err)
 		}
@@ -91,11 +95,11 @@ func TestRESTMapper(t *testing.T) {
 		if mapping.Resource != "replicationControllers" && mapping.Resource != "replicationcontrollers" {
 			t.Errorf("incorrect resource name: %#v", mapping)
 		}
-		if mapping.APIVersion != version {
+		if mapping.GroupVersionKind.GroupVersion() != currGroupVersion {
 			t.Errorf("incorrect version: %v", mapping)
 		}
 
-		interfaces, _ := latest.GroupOrDie("").InterfacesFor(version)
+		interfaces, _ := latest.GroupOrDie("").InterfacesFor(currGroupVersion.String())
 		if mapping.Codec != interfaces.Codec {
 			t.Errorf("unexpected codec: %#v, expected: %#v", mapping, interfaces)
 		}

pkg/api/mapper.go

@@ -17,9 +17,11 @@ limitations under the License.
 package api
 
 import (
+	"fmt"
 	"strings"
 
 	"k8s.io/kubernetes/pkg/api/meta"
+	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/util/sets"
 )
 
@@ -33,14 +35,23 @@ func RegisterRESTMapper(m meta.RESTMapper) {
 	RESTMapper = append(RESTMapper.(meta.MultiRESTMapper), m)
 }
 
-func NewDefaultRESTMapper(group string, versions []string, interfacesFunc meta.VersionInterfacesFunc,
+func NewDefaultRESTMapper(group string, groupVersionStrings []string, interfacesFunc meta.VersionInterfacesFunc,
 	importPathPrefix string, ignoredKinds, rootScoped sets.String) *meta.DefaultRESTMapper {
 
-	mapper := meta.NewDefaultRESTMapper(group, versions, interfacesFunc)
+	mapper := meta.NewDefaultRESTMapper(group, groupVersionStrings, interfacesFunc)
 	// enumerate all supported versions, get the kinds, and register with the mapper how to address
 	// our resources.
-	for _, version := range versions {
-		for kind, oType := range Scheme.KnownTypes(version) {
+	for _, gvString := range groupVersionStrings {
+		gv, err := unversioned.ParseGroupVersion(gvString)
+		// TODO stop panicing when the types are fixed
+		if err != nil {
+			panic(err)
+		}
+		if gv.Group != group {
+			panic(fmt.Sprintf("%q does not match the expect %q", gv.Group, group))
+		}
+
+		for kind, oType := range Scheme.KnownTypes(gv.String()) {
 			// TODO: Remove import path prefix check.
 			// We check the import path prefix because we currently stuff both "api" and "extensions" objects
 			// into the same group within Scheme since Scheme has no notion of groups yet.
@@ -51,7 +62,7 @@ func NewDefaultRESTMapper(group string, versions []string, interfacesFunc meta.V
 			if rootScoped.Has(kind) {
 				scope = meta.RESTScopeRoot
 			}
-			mapper.Add(scope, kind, version, false)
+			mapper.Add(scope, kind, gv.String(), false)
 		}
 	}
 	return mapper

pkg/api/meta/interfaces.go

@@ -17,6 +17,7 @@ limitations under the License.
 package meta
 
 import (
+	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/types"
 )
@@ -124,10 +125,8 @@ type RESTScope interface {
 type RESTMapping struct {
 	// Resource is a string representing the name of this resource as a REST client would see it
 	Resource string
-	// APIVersion represents the APIVersion that represents the resource as presented. It is provided
-	// for convenience for passing around a consistent mapping.
-	APIVersion string
-	Kind       string
+
+	GroupVersionKind unversioned.GroupVersionKind
 
 	// Scope contains the information needed to deal with REST Resources that are in a resource hierarchy
 	Scope RESTScope

pkg/api/meta/restmapper.go

@@ -20,6 +20,8 @@ package meta
 import (
 	"fmt"
 	"strings"
+
+	"k8s.io/kubernetes/pkg/api/unversioned"
 )
 
 // Implements RESTScope interface
@@ -72,12 +74,12 @@ type typeMeta struct {
 //
 // TODO: Only accept plural for some operations for increased control?
 // (`get pod bar` vs `get pods bar`)
+// TODO these maps should be keyed based on GroupVersionKinds
 type DefaultRESTMapper struct {
 	mapping        map[string]typeMeta
 	reverse        map[typeMeta]string
 	scopes         map[typeMeta]RESTScope
-	group          string
-	versions       []string
+	groupVersions  []unversioned.GroupVersion
 	plurals        map[string]string
 	singulars      map[string]string
 	interfacesFunc VersionInterfacesFunc
@@ -92,7 +94,12 @@ type VersionInterfacesFunc func(apiVersion string) (*VersionInterfaces, error)
 // and the Kubernetes API conventions. Takes a group name, a priority list of the versions
 // to search when an object has no default version (set empty to return an error),
 // and a function that retrieves the correct codec and metadata for a given version.
-func NewDefaultRESTMapper(group string, versions []string, f VersionInterfacesFunc) *DefaultRESTMapper {
+// TODO remove group when this API is fixed.  It is no longer used.
+// The external API for a RESTMapper is cross-version and this is currently called using
+// group/version tuples.  In the end, the structure may be easier to understand with
+// a GroupRESTMapper and CrossGroupRESTMapper, but for now, this one is constructed and
+// used a CrossGroupRESTMapper.
+func NewDefaultRESTMapper(group string, gvStrings []string, f VersionInterfacesFunc) *DefaultRESTMapper {
 	mapping := make(map[string]typeMeta)
 	reverse := make(map[typeMeta]string)
 	scopes := make(map[typeMeta]RESTScope)
@@ -100,23 +107,29 @@ func NewDefaultRESTMapper(group string, versions []string, f VersionInterfacesFu
 	singulars := make(map[string]string)
 	// TODO: verify name mappings work correctly when versions differ
 
+	gvs := []unversioned.GroupVersion{}
+	for _, gvString := range gvStrings {
+		gvs = append(gvs, unversioned.ParseGroupVersionOrDie(gvString))
+	}
+
 	return &DefaultRESTMapper{
 		mapping:        mapping,
 		reverse:        reverse,
 		scopes:         scopes,
-		group:          group,
-		versions:       versions,
+		groupVersions:  gvs,
 		plurals:        plurals,
 		singulars:      singulars,
 		interfacesFunc: f,
 	}
 }
 
-func (m *DefaultRESTMapper) Add(scope RESTScope, kind string, version string, mixedCase bool) {
+func (m *DefaultRESTMapper) Add(scope RESTScope, kind string, gvString string, mixedCase bool) {
+	gv := unversioned.ParseGroupVersionOrDie(gvString)
+
 	plural, singular := KindToResource(kind, mixedCase)
 	m.plurals[singular] = plural
 	m.singulars[plural] = singular
-	meta := typeMeta{APIVersion: version, Kind: kind}
+	meta := typeMeta{APIVersion: gv.String(), Kind: kind}
 	_, ok1 := m.mapping[plural]
 	_, ok2 := m.mapping[strings.ToLower(plural)]
 	if !ok1 && !ok2 {
@@ -177,74 +190,90 @@ func (m *DefaultRESTMapper) VersionAndKindForResource(resource string) (defaultV
 }
 
 func (m *DefaultRESTMapper) GroupForResource(resource string) (string, error) {
-	if _, ok := m.mapping[strings.ToLower(resource)]; !ok {
+	typemeta, exists := m.mapping[strings.ToLower(resource)]
+	if !exists {
 		return "", fmt.Errorf("in group for resource, no resource %q has been defined", resource)
 	}
-	return m.group, nil
+
+	gv, err := unversioned.ParseGroupVersion(typemeta.APIVersion)
+	if err != nil {
+		return "", err
+	}
+	return gv.Group, nil
 }
 
 // RESTMapping returns a struct representing the resource path and conversion interfaces a
 // RESTClient should use to operate on the provided kind in order of versions. If a version search
 // order is not provided, the search order provided to DefaultRESTMapper will be used to resolve which
 // APIVersion should be used to access the named kind.
+// TODO version here in this RESTMapper means just APIVersion, but the RESTMapper API is intended to handle multiple groups
+// So this API is broken.  The RESTMapper test made it clear that versions here were API versions, but the code tries to use
+// them with group/version tuples.
+// TODO this should probably become RESTMapping(GroupKind, versions ...string)
 func (m *DefaultRESTMapper) RESTMapping(kind string, versions ...string) (*RESTMapping, error) {
 	// Pick an appropriate version
-	var version string
+	var groupVersion *unversioned.GroupVersion
 	hadVersion := false
 	for _, v := range versions {
 		if len(v) == 0 {
 			continue
 		}
+		currGroupVersion, err := unversioned.ParseGroupVersion(v)
+		if err != nil {
+			return nil, err
+		}
+
 		hadVersion = true
-		if _, ok := m.reverse[typeMeta{APIVersion: v, Kind: kind}]; ok {
-			version = v
+		if _, ok := m.reverse[typeMeta{APIVersion: currGroupVersion.String(), Kind: kind}]; ok {
+			groupVersion = &currGroupVersion
 			break
 		}
 	}
 	// Use the default preferred versions
-	if !hadVersion && len(version) == 0 {
-		for _, v := range m.versions {
-			if _, ok := m.reverse[typeMeta{APIVersion: v, Kind: kind}]; ok {
-				version = v
+	if !hadVersion && (groupVersion == nil) {
+		for _, currGroupVersion := range m.groupVersions {
+			if _, ok := m.reverse[typeMeta{APIVersion: currGroupVersion.String(), Kind: kind}]; ok {
+				groupVersion = &currGroupVersion
 				break
 			}
 		}
 	}
-	if len(version) == 0 {
+	if groupVersion == nil {
 		return nil, fmt.Errorf("no kind named %q is registered in versions %q", kind, versions)
 	}
 
+	gvk := unversioned.NewGroupVersionKind(*groupVersion, kind)
+
 	// Ensure we have a REST mapping
-	resource, ok := m.reverse[typeMeta{APIVersion: version, Kind: kind}]
+	resource, ok := m.reverse[typeMeta{APIVersion: gvk.GroupVersion().String(), Kind: gvk.Kind}]
 	if !ok {
-		found := []string{}
-		for _, v := range m.versions {
-			if _, ok := m.reverse[typeMeta{APIVersion: v, Kind: kind}]; ok {
-				found = append(found, v)
+		found := []unversioned.GroupVersion{}
+		for _, gv := range m.groupVersions {
+			if _, ok := m.reverse[typeMeta{APIVersion: gv.String(), Kind: kind}]; ok {
+				found = append(found, gv)
 			}
 		}
 		if len(found) > 0 {
-			return nil, fmt.Errorf("object with kind %q exists in versions %q, not %q", kind, strings.Join(found, ", "), version)
+			return nil, fmt.Errorf("object with kind %q exists in versions %v, not %v", kind, found, *groupVersion)
 		}
-		return nil, fmt.Errorf("the provided version %q and kind %q cannot be mapped to a supported object", version, kind)
+		return nil, fmt.Errorf("the provided version %q and kind %q cannot be mapped to a supported object", groupVersion, kind)
 	}
 
 	// Ensure we have a REST scope
-	scope, ok := m.scopes[typeMeta{APIVersion: version, Kind: kind}]
+	scope, ok := m.scopes[typeMeta{APIVersion: gvk.GroupVersion().String(), Kind: gvk.Kind}]
 	if !ok {
-		return nil, fmt.Errorf("the provided version %q and kind %q cannot be mapped to a supported scope", version, kind)
+		return nil, fmt.Errorf("the provided version %q and kind %q cannot be mapped to a supported scope", gvk.GroupVersion().String(), gvk.Kind)
 	}
 
-	interfaces, err := m.interfacesFunc(version)
+	interfaces, err := m.interfacesFunc(gvk.GroupVersion().String())
 	if err != nil {
-		return nil, fmt.Errorf("the provided version %q has no relevant versions", version)
+		return nil, fmt.Errorf("the provided version %q has no relevant versions", gvk.GroupVersion().String())
 	}
 
 	retVal := &RESTMapping{
-		Resource:   resource,
-		APIVersion: version,
-		Kind:       kind,
-		Scope:      scope,
+		Resource:         resource,
+		GroupVersionKind: gvk,
+		Scope:            scope,
 
 		Codec:            interfaces.Codec,
 		ObjectConvertor:  interfaces.ObjectConvertor,

pkg/api/unversioned/group_version.go

@@ -22,7 +22,26 @@ import (
 	"strings"
 )
 
-// TODO: We need to remove the GroupVersion in types.go. We use the name GroupVersion here temporarily.
+// GroupVersionKind unambiguously identifies a kind.  It doesn't anonymously include GroupVersion
+// to avoid automatic coersion.  It doesn't use a GroupVersion to avoid custom marshalling
+type GroupVersionKind struct {
+	Group   string
+	Version string
+	Kind    string
+}
+
+func NewGroupVersionKind(gv GroupVersion, kind string) GroupVersionKind {
+	return GroupVersionKind{Group: gv.Group, Version: gv.Version, Kind: 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
@@ -31,7 +50,7 @@ type GroupVersion struct {
 
 // String puts "group" and "version" into a single "group/version" string. For the legacy v1
 // it returns "v1".
-func (gv *GroupVersion) String() string {
+func (gv GroupVersion) String() string {
 	// special case of "v1" for backward compatibility
 	if gv.Group == "" && gv.Version == "v1" {
 		return gv.Version

pkg/apis/componentconfig/install/install_test.go

@@ -21,6 +21,7 @@ import (
 	"testing"
 
 	"k8s.io/kubernetes/pkg/api/latest"
+	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/apis/componentconfig"
 )
 
@@ -53,28 +54,36 @@ func TestInterfacesFor(t *testing.T) {
 }
 
 func TestRESTMapper(t *testing.T) {
-	if v, k, err := latest.GroupOrDie("componentconfig").RESTMapper.VersionAndKindForResource("kubeproxyconfiguration"); err != nil || v != "componentconfig/v1alpha1" || k != "KubeProxyConfiguration" {
-		t.Errorf("unexpected version mapping: %s %s %v", v, k, err)
+	expectedGroupVersion := unversioned.GroupVersion{Group: "componentconfig", Version: "v1alpha1"}
+
+	if v, k, err := latest.GroupOrDie("componentconfig").RESTMapper.VersionAndKindForResource("kubeproxyconfiguration"); err != nil || v != expectedGroupVersion.String() || k != "KubeProxyConfiguration" {
+		t.Errorf("unexpected version mapping: %q %q %v", v, k, err)
 	}
 
-	if m, err := latest.GroupOrDie("componentconfig").RESTMapper.RESTMapping("KubeProxyConfiguration", ""); err != nil || m.APIVersion != "componentconfig/v1alpha1" || m.Resource != "kubeproxyconfigurations" {
+	if m, err := latest.GroupOrDie("componentconfig").RESTMapper.RESTMapping("KubeProxyConfiguration", ""); err != nil || m.GroupVersionKind.GroupVersion() != expectedGroupVersion || m.Resource != "kubeproxyconfigurations" {
 		t.Errorf("unexpected version mapping: %#v %v", m, err)
 	}
 
-	for _, groupVersion := range latest.GroupOrDie("componentconfig").GroupVersions {
-		mapping, err := latest.GroupOrDie("componentconfig").RESTMapper.RESTMapping("KubeProxyConfiguration", groupVersion)
+	for _, groupVersionString := range latest.GroupOrDie("componentconfig").GroupVersions {
+		gv, err := unversioned.ParseGroupVersion(groupVersionString)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+			continue
+		}
+		mapping, err := latest.GroupOrDie("componentconfig").RESTMapper.RESTMapping("KubeProxyConfiguration", gv.String())
 		if err != nil {
 			t.Errorf("unexpected error: %v", err)
+			continue
 		}
 
 		if mapping.Resource != "kubeproxyconfigurations" {
 			t.Errorf("incorrect resource name: %#v", mapping)
 		}
-		if mapping.APIVersion != groupVersion {
+		if mapping.GroupVersionKind.GroupVersion() != gv {
 			t.Errorf("incorrect groupVersion: %v", mapping)
 		}
 
-		interfaces, _ := latest.GroupOrDie("componentconfig").InterfacesFor(groupVersion)
+		interfaces, _ := latest.GroupOrDie("componentconfig").InterfacesFor(gv.String())
 		if mapping.Codec != interfaces.Codec {
 			t.Errorf("unexpected codec: %#v, expected: %#v", mapping, interfaces)
 		}

pkg/apis/extensions/install/install_test.go

@@ -75,16 +75,20 @@ func TestInterfacesFor(t *testing.T) {
 }
 
 func TestRESTMapper(t *testing.T) {
-	if v, k, err := latest.GroupOrDie("extensions").RESTMapper.VersionAndKindForResource("horizontalpodautoscalers"); err != nil || v != "extensions/v1beta1" || k != "HorizontalPodAutoscaler" {
+	expectedGroupVersion := unversioned.GroupVersion{Group: "extensions", Version: "v1beta1"}
+
+	if v, k, err := latest.GroupOrDie("extensions").RESTMapper.VersionAndKindForResource("horizontalpodautoscalers"); err != nil || v != expectedGroupVersion.String() || k != "HorizontalPodAutoscaler" {
 		t.Errorf("unexpected version mapping: %s %s %v", v, k, err)
 	}
 
-	if m, err := latest.GroupOrDie("extensions").RESTMapper.RESTMapping("DaemonSet", ""); err != nil || m.APIVersion != "extensions/v1beta1" || m.Resource != "daemonsets" {
+	if m, err := latest.GroupOrDie("extensions").RESTMapper.RESTMapping("DaemonSet", ""); err != nil || m.GroupVersionKind.GroupVersion() != expectedGroupVersion || m.Resource != "daemonsets" {
 		t.Errorf("unexpected version mapping: %#v %v", m, err)
 	}
 
-	for _, groupVersion := range latest.GroupOrDie("extensions").GroupVersions {
-		mapping, err := latest.GroupOrDie("extensions").RESTMapper.RESTMapping("HorizontalPodAutoscaler", groupVersion)
+	for _, groupVersionString := range latest.GroupOrDie("extensions").GroupVersions {
+		gv, err := unversioned.ParseGroupVersion(groupVersionString)
+
+		mapping, err := latest.GroupOrDie("extensions").RESTMapper.RESTMapping("HorizontalPodAutoscaler", gv.String())
 		if err != nil {
 			t.Errorf("unexpected error: %v", err)
 		}
@@ -92,11 +96,11 @@ func TestRESTMapper(t *testing.T) {
 		if mapping.Resource != "horizontalpodautoscalers" {
 			t.Errorf("incorrect resource name: %#v", mapping)
 		}
-		if mapping.APIVersion != groupVersion {
+		if mapping.GroupVersionKind.GroupVersion() != gv {
 			t.Errorf("incorrect groupVersion: %v", mapping)
 		}
 
-		interfaces, _ := latest.GroupOrDie("extensions").InterfacesFor(groupVersion)
+		interfaces, _ := latest.GroupOrDie("extensions").InterfacesFor(gv.String())
 		if mapping.Codec != interfaces.Codec {
 			t.Errorf("unexpected codec: %#v, expected: %#v", mapping, interfaces)
 		}

pkg/apiserver/watch_test.go

@@ -178,8 +178,8 @@ func TestWatchParamParsing(t *testing.T) {
 
 	dest, _ := url.Parse(server.URL)
 
-	rootPath := "/" + prefix + "/" + testVersion + "/watch/simples"
-	namespacedPath := "/" + prefix + "/" + testVersion + "/watch/namespaces/other/simpleroots"
+	rootPath := "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/watch/simples"
+	namespacedPath := "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/watch/namespaces/other/simpleroots"
 
 	table := []struct {
 		path            string
@@ -358,13 +358,13 @@ func TestWatchHTTPTimeout(t *testing.T) {
 
 	// Setup a client
 	dest, _ := url.Parse(s.URL)
-	dest.Path = "/" + prefix + "/" + newVersion + "/simple"
+	dest.Path = "/" + prefix + "/" + newGroupVersion.Group + "/" + newGroupVersion.Version + "/simple"
 	dest.RawQuery = "watch=true"
 
 	req, _ := http.NewRequest("GET", dest.String(), nil)
 	client := http.Client{}
 	resp, err := client.Do(req)
-	watcher.Add(&apiservertesting.Simple{TypeMeta: unversioned.TypeMeta{APIVersion: newVersion}})
+	watcher.Add(&apiservertesting.Simple{TypeMeta: unversioned.TypeMeta{APIVersion: newGroupVersion.String()}})
 
 	// Make sure we can actually watch an endpoint
 	decoder := json.NewDecoder(resp.Body)

pkg/kubectl/cmd/autoscale.go

@@ -96,7 +96,7 @@ func RunAutoscale(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []
 	}
 	info := infos[0]
 	mapping := info.ResourceMapping()
-	if err := f.CanBeAutoscaled(mapping.Kind); err != nil {
+	if err := f.CanBeAutoscaled(mapping.GroupVersionKind.Kind); err != nil {
 		return err
 	}
 
@@ -111,9 +111,9 @@ func RunAutoscale(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []
 	name := info.Name
 	params["default-name"] = name
 
-	params["scaleRef-kind"] = mapping.Kind
+	params["scaleRef-kind"] = mapping.GroupVersionKind.Kind
 	params["scaleRef-name"] = name
-	params["scaleRef-apiVersion"] = mapping.APIVersion
+	params["scaleRef-apiVersion"] = mapping.GroupVersionKind.GroupVersion().String()
 
 	if err = kubectl.ValidateParams(names, params); err != nil {
 		return err

pkg/kubectl/cmd/cmd_test.go

@@ -76,23 +76,27 @@ func versionErrIfFalse(b bool) error {
 	return versionErr
 }
 
+var validVersion = testapi.Default.Version()
+var internalGV = unversioned.GroupVersion{Group: "apitest", Version: ""}
+var unlikelyGV = unversioned.GroupVersion{Group: "apitest", Version: "unlikelyversion"}
+var validVersionGV = unversioned.GroupVersion{Group: "apitest", Version: validVersion}
+
 func newExternalScheme() (*runtime.Scheme, meta.RESTMapper, runtime.Codec) {
 	scheme := runtime.NewScheme()
-	scheme.AddKnownTypeWithName("", "Type", &internalType{})
-	scheme.AddKnownTypeWithName("unlikelyversion", "Type", &externalType{})
+	scheme.AddKnownTypeWithName(internalGV.Version, "Type", &internalType{})
+	scheme.AddKnownTypeWithName(unlikelyGV.String(), "Type", &externalType{})
 	//This tests that kubectl will not confuse the external scheme with the internal scheme, even when they accidentally have versions of the same name.
-	scheme.AddKnownTypeWithName(testapi.Default.Version(), "Type", &ExternalType2{})
+	scheme.AddKnownTypeWithName(validVersionGV.String(), "Type", &ExternalType2{})
 
-	codec := runtime.CodecFor(scheme, "unlikelyversion")
-	validVersion := testapi.Default.Version()
-	mapper := meta.NewDefaultRESTMapper("apitest", []string{"unlikelyversion", validVersion}, func(version string) (*meta.VersionInterfaces, error) {
+	codec := runtime.CodecFor(scheme, unlikelyGV.String())
+	mapper := meta.NewDefaultRESTMapper("apitest", []string{unlikelyGV.String(), validVersionGV.String()}, func(version string) (*meta.VersionInterfaces, error) {
 		return &meta.VersionInterfaces{
 			Codec:            runtime.CodecFor(scheme, version),
 			ObjectConvertor:  scheme,
 			MetadataAccessor: meta.NewAccessor(),
-		}, versionErrIfFalse(version == validVersion || version == "unlikelyversion")
+		}, versionErrIfFalse(version == validVersionGV.String() || version == unlikelyGV.String())
 	})
-	for _, version := range []string{"unlikelyversion", validVersion} {
+	for _, version := range []string{unlikelyGV.String(), validVersionGV.String()} {
 		for kind := range scheme.KnownTypes(version) {
 			mixedCase := false
 			scope := meta.RESTScopeNamespace

pkg/kubectl/cmd/expose.go

@@ -120,7 +120,7 @@ func RunExpose(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []str
 	}
 	info := infos[0]
 	mapping := info.ResourceMapping()
-	if err := f.CanBeExposed(mapping.Kind); err != nil {
+	if err := f.CanBeExposed(mapping.GroupVersionKind.Kind); err != nil {
 		return err
 	}
 	// Get the input object
@@ -187,7 +187,7 @@ func RunExpose(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []str
 	}
 
 	if inline := cmdutil.GetFlagString(cmd, "overrides"); len(inline) > 0 {
-		object, err = cmdutil.Merge(object, inline, mapping.Kind)
+		object, err = cmdutil.Merge(object, inline, mapping.GroupVersionKind.Kind)
 		if err != nil {
 			return err
 		}

pkg/kubectl/cmd/get_test.go

@@ -159,19 +159,19 @@ func TestGetUnknownSchemaObjectListGeneric(t *testing.T) {
 		"handles specific version": {
 			outputVersion:   testapi.Default.Version(),
 			listVersion:     testapi.Default.Version(),
-			testtypeVersion: "unlikelyversion",
+			testtypeVersion: unlikelyGV.String(),
 			rcVersion:       testapi.Default.Version(),
 		},
 		"handles second specific version": {
 			outputVersion:   "unlikelyversion",
 			listVersion:     testapi.Default.Version(),
-			testtypeVersion: "unlikelyversion",
+			testtypeVersion: unlikelyGV.String(),
 			rcVersion:       testapi.Default.Version(), // see expected behavior 3b
 		},
 		"handles common version": {
 			outputVersion:   testapi.Default.Version(),
 			listVersion:     testapi.Default.Version(),
-			testtypeVersion: "unlikelyversion",
+			testtypeVersion: unlikelyGV.String(),
 			rcVersion:       testapi.Default.Version(),
 		},
 	}
@@ -198,6 +198,7 @@ func TestGetUnknownSchemaObjectListGeneric(t *testing.T) {
 		cmd := NewCmdGet(f, buf)
 		cmd.SetOutput(buf)
 		cmd.Flags().Set("output", "json")
+
 		cmd.Flags().Set("output-version", test.outputVersion)
 		err := RunGet(f, buf, cmd, []string{"type/foo", "replicationcontrollers/foo"}, &GetOptions{})
 		if err != nil {

pkg/kubectl/cmd/rollingupdate.go

@@ -29,6 +29,7 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/api/meta"
+	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/api/v1"
 	"k8s.io/kubernetes/pkg/kubectl"
 	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
@@ -382,8 +383,9 @@ func isReplicasDefaulted(info *resource.Info) bool {
 		// was unable to recover versioned info
 		return false
 	}
-	switch info.Mapping.APIVersion {
-	case "v1":
+
+	switch info.Mapping.GroupVersionKind.GroupVersion() {
+	case unversioned.GroupVersion{Version: "v1"}:
 		if rc, ok := info.VersionedObject.(*v1.ReplicationController); ok {
 			return rc.Spec.Replicas == nil
 		}

pkg/kubectl/cmd/util/factory.go

@@ -148,7 +148,7 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory {
 			if err != nil {
 				return nil, err
 			}
-			client, err := clients.ClientForVersion(mapping.APIVersion)
+			client, err := clients.ClientForVersion(mapping.GroupVersionKind.GroupVersion().String())
 			if err != nil {
 				return nil, err
 			}
@@ -165,11 +165,11 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory {
 			if err != nil {
 				return nil, err
 			}
-			client, err := clients.ClientForVersion(mapping.APIVersion)
+			client, err := clients.ClientForVersion(mapping.GroupVersionKind.GroupVersion().String())
 			if err != nil {
 				return nil, err
 			}
-			if describer, ok := kubectl.DescriberFor(group, mapping.Kind, client); ok {
+			if describer, ok := kubectl.DescriberFor(group, mapping.GroupVersionKind.Kind, client); ok {
 				return describer, nil
 			}
 			return nil, fmt.Errorf("no description has been implemented for %q", mapping.Kind)
@@ -242,18 +242,18 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory {
 			}
 		},
 		Scaler: func(mapping *meta.RESTMapping) (kubectl.Scaler, error) {
-			client, err := clients.ClientForVersion(mapping.APIVersion)
+			client, err := clients.ClientForVersion(mapping.GroupVersionKind.GroupVersion().String())
 			if err != nil {
 				return nil, err
 			}
-			return kubectl.ScalerFor(mapping.Kind, client)
+			return kubectl.ScalerFor(mapping.GroupVersionKind.Kind, client)
 		},
 		Reaper: func(mapping *meta.RESTMapping) (kubectl.Reaper, error) {
-			client, err := clients.ClientForVersion(mapping.APIVersion)
+			client, err := clients.ClientForVersion(mapping.GroupVersionKind.GroupVersion().String())
 			if err != nil {
 				return nil, err
 			}
-			return kubectl.ReaperFor(mapping.Kind, client)
+			return kubectl.ReaperFor(mapping.GroupVersionKind.Kind, client)
 		},
 		Validator: func(validate bool, cacheDir string) (validation.Schema, error) {
 			if validate {
@@ -581,12 +581,12 @@ func (f *Factory) PrinterForMapping(cmd *cobra.Command, mapping *meta.RESTMappin
 
 		version := OutputVersion(cmd, defaultVersion)
 		if len(version) == 0 {
-			version = mapping.APIVersion
+			version = mapping.GroupVersionKind.GroupVersion().String()
 		}
 		if len(version) == 0 {
 			return nil, fmt.Errorf("you must specify an output-version when using this output format")
 		}
-		printer = kubectl.NewVersionedPrinter(printer, mapping.ObjectConvertor, version, mapping.APIVersion)
+		printer = kubectl.NewVersionedPrinter(printer, mapping.ObjectConvertor, version, mapping.GroupVersionKind.GroupVersion().String())
 	} else {
 		// Some callers do not have "label-columns" so we can't use the GetFlagStringSlice() helper
 		columnLabel, err := cmd.Flags().GetStringSlice("label-columns")

pkg/kubectl/resource/builder_test.go

@@ -470,7 +470,7 @@ func TestResourceByNameWithoutRequireObject(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	if mapping.Kind != "Pod" || mapping.Resource != "pods" {
+	if mapping.GroupVersionKind.Kind != "Pod" || mapping.Resource != "pods" {
 		t.Errorf("unexpected resource mapping: %#v", mapping)
 	}
 }

pkg/kubectl/resource/result.go

@@ -254,7 +254,7 @@ func AsVersionedObjects(infos []*Info, version string) ([]runtime.Object, error)
 			}
 		}
 
-		converted, err := tryConvert(info.Mapping.ObjectConvertor, info.Object, version, info.Mapping.APIVersion)
+		converted, err := tryConvert(info.Mapping.ObjectConvertor, info.Object, version, info.Mapping.GroupVersionKind.GroupVersion().String())
 		if err != nil {
 			return nil, err
 		}

pkg/kubectl/resource/selector.go

@@ -45,7 +45,7 @@ func NewSelector(client RESTClient, mapping *meta.RESTMapping, namespace string,
 
 // Visit implements Visitor
 func (r *Selector) Visit(fn VisitorFunc) error {
-	list, err := NewHelper(r.Client, r.Mapping).List(r.Namespace, r.ResourceMapping().APIVersion, r.Selector)
+	list, err := NewHelper(r.Client, r.Mapping).List(r.Namespace, r.ResourceMapping().GroupVersionKind.GroupVersion().String(), r.Selector)
 	if err != nil {
 		if errors.IsBadRequest(err) || errors.IsNotFound(err) {
 			if r.Selector.Empty() {
@@ -70,7 +70,7 @@ func (r *Selector) Visit(fn VisitorFunc) error {
 }
 
 func (r *Selector) Watch(resourceVersion string) (watch.Interface, error) {
-	return NewHelper(r.Client, r.Mapping).Watch(r.Namespace, resourceVersion, r.ResourceMapping().APIVersion, r.Selector)
+	return NewHelper(r.Client, r.Mapping).Watch(r.Namespace, resourceVersion, r.ResourceMapping().GroupVersionKind.GroupVersion().String(), r.Selector)
 }
 
 // ResourceMapping returns the mapping for this resource and implements ResourceMapping