Merge pull request #19674 from nikhiljindal/latestAndRegistered

cmd/kube-apiserver/app/options/options.go

@@ -24,8 +24,8 @@ import (
 
 	"k8s.io/kubernetes/pkg/admission"
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/validation"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/apiserver"
 	"k8s.io/kubernetes/pkg/genericapiserver"
 	kubeletclient "k8s.io/kubernetes/pkg/kubelet/client"
@@ -96,7 +96,7 @@ func NewAPIServer() *APIServer {
 		MasterCount:            1,
 		MasterServiceNamespace: api.NamespaceDefault,
 		RuntimeConfig:          make(util.ConfigurationMap),
-		StorageVersions:        latest.AllPreferredGroupVersions(),
+		StorageVersions:        registered.AllPreferredGroupVersions(),
 		KubeletConfig: kubeletclient.KubeletClientConfig{
 			Port:        ports.KubeletPort,
 			EnableHttps: true,

cmd/kube-apiserver/app/server.go

@@ -34,10 +34,10 @@ import (
 	"k8s.io/kubernetes/cmd/kube-apiserver/app/options"
 	"k8s.io/kubernetes/pkg/admission"
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/meta"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	apiutil "k8s.io/kubernetes/pkg/api/util"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	"k8s.io/kubernetes/pkg/apiserver"
 	"k8s.io/kubernetes/pkg/apiserver/authenticator"
@@ -138,7 +138,7 @@ func updateEtcdOverrides(overrides []string, storageVersions map[string]string,
 		group := apiresource[0]
 		resource := apiresource[1]
 
-		apigroup, err := latest.Group(group)
+		apigroup, err := registered.Group(group)
 		if err != nil {
 			glog.Errorf("invalid api group %s: %v", group, err)
 			continue
@@ -249,7 +249,7 @@ func Run(s *options.APIServer) error {
 		glog.Fatalf("Invalid server address: %v", err)
 	}
 
-	legacyV1Group, err := latest.Group(api.GroupName)
+	legacyV1Group, err := registered.Group(api.GroupName)
 	if err != nil {
 		return err
 	}
@@ -267,7 +267,7 @@ func Run(s *options.APIServer) error {
 	storageDestinations.AddAPIGroup("", etcdStorage)
 
 	if !apiGroupVersionOverrides["extensions/v1beta1"].Disable {
-		expGroup, err := latest.Group(extensions.GroupName)
+		expGroup, err := registered.Group(extensions.GroupName)
 		if err != nil {
 			glog.Fatalf("Extensions API is enabled in runtime config, but not enabled in the environment variable KUBE_API_VERSIONS. Error: %v", err)
 		}

cmd/libs/go2idl/client-gen/generators/generator-for-group.go

@@ -54,7 +54,7 @@ func (g *genGroup) Imports(c *generator.Context) (imports []string) {
 func (g *genGroup) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error {
 	sw := generator.NewSnippetWriter(w, c, "$", "$")
 	const pkgUnversioned = "k8s.io/kubernetes/pkg/client/unversioned"
-	const pkgLatest = "k8s.io/kubernetes/pkg/api/latest"
+	const pkgRegistered = "k8s.io/kubernetes/pkg/apimachinery/registered"
 	apiPath := func(group string) string {
 		if group == "legacy" {
 			return `"/api"`
@@ -78,8 +78,8 @@ func (g *genGroup) GenerateType(c *generator.Context, t *types.Type, w io.Writer
 		"DefaultKubernetesUserAgent": c.Universe.Function(types.Name{Package: pkgUnversioned, Name: "DefaultKubernetesUserAgent"}),
 		"RESTClient":                 c.Universe.Type(types.Name{Package: pkgUnversioned, Name: "RESTClient"}),
 		"RESTClientFor":              c.Universe.Function(types.Name{Package: pkgUnversioned, Name: "RESTClientFor"}),
-		"latestGroup":                c.Universe.Variable(types.Name{Package: pkgLatest, Name: "Group"}),
-		"GroupOrDie":                 c.Universe.Variable(types.Name{Package: pkgLatest, Name: "GroupOrDie"}),
+		"latestGroup":                c.Universe.Variable(types.Name{Package: pkgRegistered, Name: "Group"}),
+		"GroupOrDie":                 c.Universe.Variable(types.Name{Package: pkgRegistered, Name: "GroupOrDie"}),
 		"apiPath":                    apiPath(g.group),
 	}
 	sw.Do(groupInterfaceTemplate, m)

cmd/libs/go2idl/client-gen/main.go

@@ -76,8 +76,8 @@ func main() {
 		"k8s.io/kubernetes/pkg/labels",
 		"k8s.io/kubernetes/pkg/watch",
 		"k8s.io/kubernetes/pkg/client/unversioned",
-		"k8s.io/kubernetes/pkg/api/latest",
 		"k8s.io/kubernetes/pkg/client/testing/fake",
+		"k8s.io/kubernetes/pkg/apimachinery/registered",
 	}
 
 	if *test {

cmd/libs/go2idl/client-gen/testdata/apis/testgroup/install/install.go

@@ -26,9 +26,10 @@ import (
 	"k8s.io/kubernetes/cmd/libs/go2idl/client-gen/testdata/apis/testgroup"
 	"k8s.io/kubernetes/cmd/libs/go2idl/client-gen/testdata/apis/testgroup/v1"
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/meta"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util/sets"
 )
@@ -44,10 +45,27 @@ var availableVersions = []unversioned.GroupVersion{{Group: groupName, Version: "
 
 func init() {
 	externalVersions := availableVersions
-	preferredExternalVersion := externalVersions[0]
+	registered.RegisterVersions(availableVersions)
+
+	if err := registered.EnableVersions(externalVersions...); err != nil {
+		glog.V(4).Infof("%v", err)
+		return
+	}
+	if err := enableVersions(externalVersions); err != nil {
+		glog.V(4).Infof("%v", err)
+		return
+	}
+}
+
+// TODO: enableVersions should be centralized rather than spread in each API
+// group.
+// We can combine registered.RegisterVersions, registered.EnableVersions and
+// registered.RegisterGroup once we have moved enableVersions there.
+func enableVersions(externalVersions []unversioned.GroupVersion) error {
 	addVersionsToScheme(externalVersions...)
+	preferredExternalVersion := externalVersions[0]
 
-	groupMeta := latest.GroupMeta{
+	groupMeta := apimachinery.GroupMeta{
 		GroupVersion:  preferredExternalVersion,
 		GroupVersions: externalVersions,
 		Codec:         runtime.CodecFor(api.Scheme, preferredExternalVersion),
@@ -56,12 +74,11 @@ func init() {
 		InterfacesFor: interfacesFor,
 	}
 
-	if err := latest.RegisterGroup(groupMeta); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
+	if err := registered.RegisterGroup(groupMeta); err != nil {
+		return err
 	}
-
 	api.RegisterRESTMapper(groupMeta.RESTMapper)
+	return nil
 }
 
 func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
@@ -85,7 +102,7 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
 			MetadataAccessor: accessor,
 		}, nil
 	default:
-		g, _ := latest.Group(groupName)
+		g, _ := registered.Group(groupName)
 		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
 	}
 }

cmd/libs/go2idl/client-gen/testoutput/testgroup/unversioned/testgroup_client.go

@@ -18,7 +18,7 @@ package unversioned
 
 import (
 	"fmt"
-	latest "k8s.io/kubernetes/pkg/api/latest"
+	registered "k8s.io/kubernetes/pkg/apimachinery/registered"
 	unversioned "k8s.io/kubernetes/pkg/client/unversioned"
 )
 
@@ -65,7 +65,7 @@ func New(c *unversioned.RESTClient) *TestgroupClient {
 
 func setConfigDefaults(config *unversioned.Config) error {
 	// if testgroup group is not registered, return an error
-	g, err := latest.Group("testgroup")
+	g, err := registered.Group("testgroup")
 	if err != nil {
 		return err
 	}

cmd/libs/go2idl/client-gen/testoutput/testgroup/unversioned/testgroup_test.go

@@ -25,9 +25,9 @@ import (
 	_ "k8s.io/kubernetes/cmd/libs/go2idl/client-gen/testdata/apis/testgroup/install"
 	. "k8s.io/kubernetes/cmd/libs/go2idl/client-gen/testoutput/testgroup/unversioned"
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/testapi"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/client/unversioned/testclient/simple"
 	"k8s.io/kubernetes/pkg/labels"
@@ -40,7 +40,7 @@ func init() {
 		return
 	}
 	testapi.Groups[testgroup.SchemeGroupVersion.Group] = testapi.NewTestGroup(
-		unversioned.GroupVersion{Group: testgroup.SchemeGroupVersion.Group, Version: latest.GroupOrDie(testgroup.SchemeGroupVersion.Group).GroupVersion.Version},
+		unversioned.GroupVersion{Group: testgroup.SchemeGroupVersion.Group, Version: registered.GroupOrDie(testgroup.SchemeGroupVersion.Group).GroupVersion.Version},
 		testgroup.SchemeGroupVersion)
 	testHelper = testapi.Groups[testgroup.SchemeGroupVersion.Group]
 }

examples/https-nginx/make_secret.go

@@ -27,7 +27,7 @@ import (
 	"log"
 
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/runtime"
 
 	// This installs the legacy v1 API
@@ -66,5 +66,5 @@ func main() {
 			"nginx.key": nginxKey,
 		},
 	}
-	fmt.Printf(runtime.EncodeOrDie(latest.GroupOrDie(api.GroupName).Codec, secret))
+	fmt.Printf(runtime.EncodeOrDie(registered.GroupOrDie(api.GroupName).Codec, secret))
 }

examples/sharing-clusters/make_secret.go

@@ -24,7 +24,7 @@ import (
 	"log"
 
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/runtime"
 )
 
@@ -59,5 +59,5 @@ func main() {
 			"config": cfg,
 		},
 	}
-	fmt.Printf(runtime.EncodeOrDie(latest.GroupOrDie(api.GroupName).Codec, secret))
+	fmt.Printf(runtime.EncodeOrDie(registered.GroupOrDie(api.GroupName).Codec, secret))
 }

pkg/api/install/install.go

@@ -24,8 +24,8 @@ import (
 	"github.com/golang/glog"
 
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
-	"k8s.io/kubernetes/pkg/api/registered"
+	"k8s.io/kubernetes/pkg/apimachinery"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/util/sets"
 
 	"k8s.io/kubernetes/pkg/api/meta"
@@ -42,8 +42,7 @@ var accessor = meta.NewAccessor()
 var availableVersions = []unversioned.GroupVersion{v1.SchemeGroupVersion}
 
 func init() {
-	registered.RegisterVersions(availableVersions...)
-
+	registered.RegisterVersions(availableVersions)
 	externalVersions := []unversioned.GroupVersion{}
 	for _, v := range availableVersions {
 		if registered.IsAllowedVersion(v) {
@@ -54,6 +53,7 @@ func init() {
 		glog.V(4).Infof("No version is registered for group %v", api.GroupName)
 		return
 	}
+
 	if err := registered.EnableVersions(externalVersions...); err != nil {
 		glog.V(4).Infof("%v", err)
 		return
@@ -66,11 +66,13 @@ func init() {
 
 // TODO: enableVersions should be centralized rather than spread in each API
 // group.
+// We can combine registered.RegisterVersions, registered.EnableVersions and
+// registered.RegisterGroup once we have moved enableVersions there.
 func enableVersions(externalVersions []unversioned.GroupVersion) error {
 	addVersionsToScheme(externalVersions...)
 	preferredExternalVersion := externalVersions[0]
 
-	groupMeta := latest.GroupMeta{
+	groupMeta := apimachinery.GroupMeta{
 		GroupVersion:  preferredExternalVersion,
 		GroupVersions: externalVersions,
 		Codec:         runtime.CodecFor(api.Scheme, preferredExternalVersion),
@@ -79,7 +81,7 @@ func enableVersions(externalVersions []unversioned.GroupVersion) error {
 		InterfacesFor: interfacesFor,
 	}
 
-	if err := latest.RegisterGroup(groupMeta); err != nil {
+	if err := registered.RegisterGroup(groupMeta); err != nil {
 		return err
 	}
 	api.RegisterRESTMapper(groupMeta.RESTMapper)
@@ -130,7 +132,7 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
 			MetadataAccessor: accessor,
 		}, nil
 	default:
-		g, _ := latest.Group(api.GroupName)
+		g, _ := registered.Group(api.GroupName)
 		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
 	}
 }

pkg/api/install/install_test.go

@@ -21,8 +21,8 @@ import (
 	"testing"
 
 	internal "k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 )
 
 func TestResourceVersioner(t *testing.T) {
@@ -47,9 +47,9 @@ func TestResourceVersioner(t *testing.T) {
 
 func TestCodec(t *testing.T) {
 	pod := internal.Pod{}
-	// We do want to use package latest rather than testapi here, because we
-	// want to test if the package install and package latest work as expected.
-	data, err := latest.GroupOrDie(internal.GroupName).Codec.Encode(&pod)
+	// We do want to use package registered rather than testapi here, because we
+	// want to test if the package install and package registered work as expected.
+	data, err := registered.GroupOrDie(internal.GroupName).Codec.Encode(&pod)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -57,17 +57,17 @@ func TestCodec(t *testing.T) {
 	if err := json.Unmarshal(data, &other); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	if other.APIVersion != latest.GroupOrDie(internal.GroupName).GroupVersion.Version || other.Kind != "Pod" {
+	if other.APIVersion != registered.GroupOrDie(internal.GroupName).GroupVersion.Version || other.Kind != "Pod" {
 		t.Errorf("unexpected unmarshalled object %#v", other)
 	}
 }
 
 func TestInterfacesFor(t *testing.T) {
-	if _, err := latest.GroupOrDie(internal.GroupName).InterfacesFor(internal.SchemeGroupVersion); err == nil {
+	if _, err := registered.GroupOrDie(internal.GroupName).InterfacesFor(internal.SchemeGroupVersion); err == nil {
 		t.Fatalf("unexpected non-error: %v", err)
 	}
-	for i, version := range latest.GroupOrDie(internal.GroupName).GroupVersions {
-		if vi, err := latest.GroupOrDie(internal.GroupName).InterfacesFor(version); err != nil || vi == nil {
+	for i, version := range registered.GroupOrDie(internal.GroupName).GroupVersions {
+		if vi, err := registered.GroupOrDie(internal.GroupName).InterfacesFor(version); err != nil || vi == nil {
 			t.Fatalf("%d: unexpected result: %v", i, err)
 		}
 	}
@@ -78,16 +78,16 @@ func TestRESTMapper(t *testing.T) {
 	rcGVK := gv.WithKind("ReplicationController")
 	podTemplateGVK := gv.WithKind("PodTemplate")
 
-	if gvk, err := latest.GroupOrDie(internal.GroupName).RESTMapper.KindFor(internal.SchemeGroupVersion.WithResource("replicationcontrollers")); err != nil || gvk != rcGVK {
+	if gvk, err := registered.GroupOrDie(internal.GroupName).RESTMapper.KindFor(internal.SchemeGroupVersion.WithResource("replicationcontrollers")); err != nil || gvk != rcGVK {
 		t.Errorf("unexpected version mapping: %v %v", gvk, err)
 	}
 
-	if m, err := latest.GroupOrDie(internal.GroupName).RESTMapper.RESTMapping(podTemplateGVK.GroupKind(), ""); err != nil || m.GroupVersionKind != podTemplateGVK || m.Resource != "podtemplates" {
+	if m, err := registered.GroupOrDie(internal.GroupName).RESTMapper.RESTMapping(podTemplateGVK.GroupKind(), ""); err != nil || m.GroupVersionKind != podTemplateGVK || m.Resource != "podtemplates" {
 		t.Errorf("unexpected version mapping: %#v %v", m, err)
 	}
 
-	for _, version := range latest.GroupOrDie(internal.GroupName).GroupVersions {
-		mapping, err := latest.GroupOrDie(internal.GroupName).RESTMapper.RESTMapping(rcGVK.GroupKind(), version.Version)
+	for _, version := range registered.GroupOrDie(internal.GroupName).GroupVersions {
+		mapping, err := registered.GroupOrDie(internal.GroupName).RESTMapper.RESTMapping(rcGVK.GroupKind(), version.Version)
 		if err != nil {
 			t.Errorf("unexpected error: %v", err)
 		}
@@ -99,7 +99,7 @@ func TestRESTMapper(t *testing.T) {
 			t.Errorf("incorrect version: %v", mapping)
 		}
 
-		interfaces, _ := latest.GroupOrDie(internal.GroupName).InterfacesFor(version)
+		interfaces, _ := registered.GroupOrDie(internal.GroupName).InterfacesFor(version)
 		if mapping.Codec != interfaces.Codec {
 			t.Errorf("unexpected codec: %#v, expected: %#v", mapping, interfaces)
 		}

pkg/api/latest/latest.go

-/*
-Copyright 2014 The Kubernetes Authors All rights reserved.
-
-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 latest
-
-import (
-	"fmt"
-	"sort"
-	"strings"
-
-	"k8s.io/kubernetes/pkg/api/meta"
-	"k8s.io/kubernetes/pkg/api/unversioned"
-	"k8s.io/kubernetes/pkg/runtime"
-)
-
-var (
-	allGroups = GroupMetaMap{}
-	// Group is a shortcut to allGroups.Group.
-	Group = allGroups.Group
-	// RegisterGroup is a shortcut to allGroups.RegisterGroup.
-	RegisterGroup = allGroups.RegisterGroup
-	// GroupOrDie is a shortcut to allGroups.GroupOrDie.
-	GroupOrDie = allGroups.GroupOrDie
-	// AllPreferredGroupVersions returns the preferred versions of all
-	// registered groups in the form of "group1/version1,group2/version2,..."
-	AllPreferredGroupVersions = allGroups.AllPreferredGroupVersions
-	// IsRegistered is a shortcut to allGroups.IsRegistered.
-	IsRegistered = allGroups.IsRegistered
-)
-
-// ExternalVersions is a list of all external versions for this API group in order of
-// most preferred to least preferred
-var ExternalVersions = []unversioned.GroupVersion{
-	{Group: "", Version: "v1"},
-}
-
-// GroupMetaMap is a map between group names and their metadata.
-type GroupMetaMap map[string]*GroupMeta
-
-// RegisterGroup registers a group to GroupMetaMap.
-func (g GroupMetaMap) RegisterGroup(groupMeta GroupMeta) error {
-	groupName := groupMeta.GroupVersion.Group
-	if _, found := g[groupName]; found {
-		return fmt.Errorf("group %v is already registered", g)
-	}
-
-	g[groupName] = &groupMeta
-	return nil
-}
-
-// Group returns the metadata of a group if the gruop is registered, otherwise
-// an erorr is returned.
-func (g GroupMetaMap) Group(group string) (*GroupMeta, error) {
-	groupMeta, found := g[group]
-	if !found {
-		return nil, fmt.Errorf("no version is registered for group %v", group)
-	}
-	groupMetaCopy := *groupMeta
-	return &groupMetaCopy, nil
-}
-
-// IsRegistered takes a string and determines if it's one of the registered groups
-func (g GroupMetaMap) IsRegistered(group string) bool {
-	_, found := g[group]
-	return found
-}
-
-// TODO: This is an expedient function, because we don't check if a Group is
-// supported throughout the code base. We will abandon this function and
-// checking the error returned by the Group() function.
-func (g GroupMetaMap) GroupOrDie(group string) *GroupMeta {
-	groupMeta, found := g[group]
-	if !found {
-		const msg = "Please check the KUBE_API_VERSIONS environment variable."
-		if group == "" {
-			panic("The legacy v1 API is not registered. " + msg)
-		} else {
-			panic(fmt.Sprintf("No version is registered for group %s. ", group) + msg)
-		}
-	}
-	groupMetaCopy := *groupMeta
-	return &groupMetaCopy
-}
-
-// AllPreferredGroupVersions returns the preferred versions of all registered
-// groups in the form of "group1/version1,group2/version2,..."
-func (g GroupMetaMap) AllPreferredGroupVersions() string {
-	if len(g) == 0 {
-		return ""
-	}
-	var defaults []string
-	for _, groupMeta := range g {
-		defaults = append(defaults, groupMeta.GroupVersion.String())
-	}
-	sort.Strings(defaults)
-	return strings.Join(defaults, ",")
-}
-
-// GroupMeta stores the metadata of a group, such as the latest supported version.
-type GroupMeta struct {
-	// GroupVersion represents the current external default version of the group.
-	GroupVersion unversioned.GroupVersion
-
-	// GroupVersions is Group + Versions. This is to avoid string concatenation
-	// in many places.
-	GroupVersions []unversioned.GroupVersion
-
-	// Codec is the default codec for serializing output that should use
-	// the latest supported version.  Use this Codec when writing to
-	// disk, a data store that is not dynamically versioned, or in tests.
-	// This codec can decode any object that Kubernetes is aware of.
-	Codec runtime.Codec
-
-	// SelfLinker can set or get the SelfLink field of all API types.
-	// TODO: when versioning changes, make this part of each API definition.
-	// TODO(lavalamp): Combine SelfLinker & ResourceVersioner interfaces, force all uses
-	// to go through the InterfacesFor method below.
-	SelfLinker runtime.SelfLinker
-
-	// RESTMapper provides the default mapping between REST paths and the objects declared in api.Scheme and all known
-	// Kubernetes versions.
-	RESTMapper meta.RESTMapper
-
-	// InterfacesFor returns the default Codec and ResourceVersioner for a given version
-	// or an error if the version is not known.
-	InterfacesFor func(version unversioned.GroupVersion) (*meta.VersionInterfaces, error)
-}

pkg/api/testapi/testapi.go

@@ -27,9 +27,9 @@ import (
 	_ "k8s.io/kubernetes/pkg/apis/extensions/install"
 	_ "k8s.io/kubernetes/pkg/apis/metrics/install"
 
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/meta"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	"k8s.io/kubernetes/pkg/runtime"
 )
@@ -64,13 +64,13 @@ func init() {
 
 	if _, ok := Groups[api.GroupName]; !ok {
 		Groups[api.GroupName] = TestGroup{
-			externalGroupVersion: unversioned.GroupVersion{Group: api.GroupName, Version: latest.GroupOrDie(api.GroupName).GroupVersion.Version},
+			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: latest.GroupOrDie(extensions.GroupName).GroupVersion.Version},
+			externalGroupVersion: unversioned.GroupVersion{Group: extensions.GroupName, Version: registered.GroupOrDie(extensions.GroupName).GroupVersion.Version},
 			internalGroupVersion: extensions.SchemeGroupVersion,
 		}
 	}
@@ -93,8 +93,8 @@ func (g TestGroup) InternalGroupVersion() unversioned.GroupVersion {
 // Codec returns the codec for the API version to test against, as set by the
 // KUBE_TEST_API env var.
 func (g TestGroup) Codec() runtime.Codec {
-	// TODO: caesarxuchao: Restructure the body once we have a central `latest`.
-	interfaces, err := latest.GroupOrDie(g.externalGroupVersion.Group).InterfacesFor(g.externalGroupVersion)
+	// TODO: caesarxuchao: Restructure the body once we have a central `registered`.
+	interfaces, err := registered.GroupOrDie(g.externalGroupVersion.Group).InterfacesFor(g.externalGroupVersion)
 	if err != nil {
 		panic(err)
 	}
@@ -104,7 +104,7 @@ func (g TestGroup) Codec() runtime.Codec {
 // Converter returns the api.Scheme for the API version to test against, as set by the
 // KUBE_TEST_API env var.
 func (g TestGroup) Converter() runtime.ObjectConvertor {
-	interfaces, err := latest.GroupOrDie(g.externalGroupVersion.Group).InterfacesFor(g.externalGroupVersion)
+	interfaces, err := registered.GroupOrDie(g.externalGroupVersion.Group).InterfacesFor(g.externalGroupVersion)
 	if err != nil {
 		panic(err)
 	}
@@ -114,7 +114,7 @@ func (g TestGroup) Converter() runtime.ObjectConvertor {
 // MetadataAccessor returns the MetadataAccessor for the API version to test against,
 // as set by the KUBE_TEST_API env var.
 func (g TestGroup) MetadataAccessor() meta.MetadataAccessor {
-	interfaces, err := latest.GroupOrDie(g.externalGroupVersion.Group).InterfacesFor(g.externalGroupVersion)
+	interfaces, err := registered.GroupOrDie(g.externalGroupVersion.Group).InterfacesFor(g.externalGroupVersion)
 	if err != nil {
 		panic(err)
 	}
@@ -178,7 +178,7 @@ func (g TestGroup) ResourcePath(resource, namespace, name string) string {
 }
 
 func (g TestGroup) RESTMapper() meta.RESTMapper {
-	return latest.GroupOrDie(g.externalGroupVersion.Group).RESTMapper
+	return registered.GroupOrDie(g.externalGroupVersion.Group).RESTMapper
 }
 
 // Get codec based on runtime.Object

pkg/api/latest/doc.go → pkg/apimachinery/doc.go

@@ -14,8 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Package latest defines the default output serializations that code should
-// use and imports the required schemas.  It also ensures all previously known
-// and supported API versions are available for conversion. Consumers may
-// import this package in lieu of importing individual versions.
-package latest
+// Package apimachinery contains the generic API machinery code that
+// is common to both server and clients.
+// This package should never import specific API objects.
+package apimachinery

pkg/api/registered/registered.go → pkg/apimachinery/registered/registered.go

@@ -14,21 +14,22 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Package to keep track of API Versions that should be registered in api.Scheme.
+// Package to keep track of API Versions that can be registered and are enabled in api.Scheme.
 package registered
 
 import (
 	"fmt"
 	"os"
+	"sort"
 	"strings"
 
 	"github.com/golang/glog"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery"
 )
 
 var (
-	// registeredVersions represents all registered API versions. Please call
-	// RegisterVersions() to add registered versions.
+	// registeredGroupVersions stores all API group versions for which RegisterGroup is called.
 	registeredVersions = map[unversioned.GroupVersion]struct{}{}
 
 	// enabledVersions represents all enabled API versions. It should be a
@@ -36,6 +37,9 @@ var (
 	// enabled versions.
 	enabledVersions = map[unversioned.GroupVersion]struct{}{}
 
+	// map of group meta for all groups.
+	groupMetaMap = map[string]*apimachinery.GroupMeta{}
+
 	// envRequestedVersions represents the versions requested via the
 	// KUBE_API_VERSIONS environment variable. The install package of each group
 	// checks this list before add their versions to the latest package and
@@ -59,15 +63,26 @@ func init() {
 	}
 }
 
-// RegisterVersions add the versions the registeredVersions.
-func RegisterVersions(versions ...unversioned.GroupVersion) {
-	for _, v := range versions {
+// RegisterVersions adds the given group versions to the list of registered group versions.
+func RegisterVersions(availableVersions []unversioned.GroupVersion) {
+	for _, v := range availableVersions {
 		registeredVersions[v] = struct{}{}
 	}
 }
 
-// EnableVersions add the versions to the enabledVersions. The caller of this
-// function is responsible to add the version to 'latest' and 'Scheme'.
+// RegisterGroup adds the given group to the list of registered groups.
+func RegisterGroup(groupMeta apimachinery.GroupMeta) error {
+	groupName := groupMeta.GroupVersion.Group
+	if _, found := groupMetaMap[groupName]; found {
+		return fmt.Errorf("group %v is already registered", groupMetaMap)
+	}
+	groupMetaMap[groupName] = &groupMeta
+	return nil
+}
+
+// EnableVersions adds the versions for the given group to the list of enabled versions.
+// Note that the caller should call RegisterGroup before calling this method.
+// The caller of this function is responsible to add the versions to scheme and RESTMapper.
 func EnableVersions(versions ...unversioned.GroupVersion) error {
 	var unregisteredVersions []unversioned.GroupVersion
 	for _, v := range versions {
@@ -99,12 +114,6 @@ func IsEnabledVersion(v unversioned.GroupVersion) bool {
 	return found
 }
 
-// IsRegisteredVersion returns if a version is registered.
-func IsRegisteredVersion(v unversioned.GroupVersion) bool {
-	_, found := registeredVersions[v]
-	return found
-}
-
 // EnabledVersions returns all enabled versions.
 func EnabledVersions() (ret []unversioned.GroupVersion) {
 	for v := range enabledVersions {
@@ -113,14 +122,6 @@ func EnabledVersions() (ret []unversioned.GroupVersion) {
 	return
 }
 
-// RegisteredVersions returns all registered versions.
-func RegisteredVersions() (ret []unversioned.GroupVersion) {
-	for v := range registeredVersions {
-		ret = append(ret, v)
-	}
-	return
-}
-
 // EnabledVersionsForGroup returns all enabled versions for a group.
 func EnabledVersionsForGroup(group string) (ret []unversioned.GroupVersion) {
 	for v := range enabledVersions {
@@ -131,14 +132,51 @@ func EnabledVersionsForGroup(group string) (ret []unversioned.GroupVersion) {
 	return
 }
 
-// RegisteredVersionsForGroup returns all registered versions for a group.
-func RegisteredVersionsForGroup(group string) (ret []unversioned.GroupVersion) {
-	for v := range registeredVersions {
-		if v.Group == group {
-			ret = append(ret, v)
+// Group returns the metadata of a group if the gruop is registered, otherwise
+// an erorr is returned.
+func Group(group string) (*apimachinery.GroupMeta, error) {
+	groupMeta, found := groupMetaMap[group]
+	if !found {
+		return nil, fmt.Errorf("group %v has not been registered", group)
+	}
+	groupMetaCopy := *groupMeta
+	return &groupMetaCopy, nil
+}
+
+// IsRegistered takes a string and determines if it's one of the registered groups
+func IsRegistered(group string) bool {
+	_, found := groupMetaMap[group]
+	return found
+}
+
+// TODO: This is an expedient function, because we don't check if a Group is
+// supported throughout the code base. We will abandon this function and
+// checking the error returned by the Group() function.
+func GroupOrDie(group string) *apimachinery.GroupMeta {
+	groupMeta, found := groupMetaMap[group]
+	if !found {
+		if group == "" {
+			panic("The legacy v1 API is not registered.")
+		} else {
+			panic(fmt.Sprintf("Group %s is not registered.", group))
 		}
 	}
-	return
+	groupMetaCopy := *groupMeta
+	return &groupMetaCopy
+}
+
+// AllPreferredGroupVersions returns the preferred versions of all registered
+// groups in the form of "group1/version1,group2/version2,..."
+func AllPreferredGroupVersions() string {
+	if len(groupMetaMap) == 0 {
+		return ""
+	}
+	var defaults []string
+	for _, groupMeta := range groupMetaMap {
+		defaults = append(defaults, groupMeta.GroupVersion.String())
+	}
+	sort.Strings(defaults)
+	return strings.Join(defaults, ",")
 }
 
 // ValidateEnvRequestedVersions returns a list of versions that are requested in
@@ -152,3 +190,12 @@ func ValidateEnvRequestedVersions() []unversioned.GroupVersion {
 	}
 	return missingVersions
 }
+
+// Resets the state.
+// Should not be used by anyone else than tests.
+func reset() {
+	registeredVersions = map[unversioned.GroupVersion]struct{}{}
+	enabledVersions = map[unversioned.GroupVersion]struct{}{}
+	groupMetaMap = map[string]*apimachinery.GroupMeta{}
+
+}

pkg/api/latest/latest_test.go → pkg/apimachinery/registered/registered_test.go

@@ -14,50 +14,55 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package latest
+package registered
 
 import (
 	"testing"
 
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery"
 )
 
 func TestAllPreferredGroupVersions(t *testing.T) {
 	testCases := []struct {
-		groupMetaMap GroupMetaMap
-		expect       string
+		groupMetas []apimachinery.GroupMeta
+		expect     string
 	}{
 		{
-			groupMetaMap: GroupMetaMap{
-				"group1": &GroupMeta{
+			groupMetas: []apimachinery.GroupMeta{
+				{
 					GroupVersion: unversioned.GroupVersion{"group1", "v1"},
 				},
-				"group2": &GroupMeta{
+				{
 					GroupVersion: unversioned.GroupVersion{"group2", "v2"},
 				},
-				"": &GroupMeta{
+				{
 					GroupVersion: unversioned.GroupVersion{"", "v1"},
 				},
 			},
 			expect: "group1/v1,group2/v2,v1",
 		},
 		{
-			groupMetaMap: GroupMetaMap{
-				"": &GroupMeta{
+			groupMetas: []apimachinery.GroupMeta{
+				{
 					GroupVersion: unversioned.GroupVersion{"", "v1"},
 				},
 			},
 			expect: "v1",
 		},
 		{
-			groupMetaMap: GroupMetaMap{},
-			expect:       "",
+			groupMetas: []apimachinery.GroupMeta{},
+			expect:     "",
 		},
 	}
 	for _, testCase := range testCases {
-		output := testCase.groupMetaMap.AllPreferredGroupVersions()
+		for _, groupMeta := range testCase.groupMetas {
+			RegisterGroup(groupMeta)
+		}
+		output := AllPreferredGroupVersions()
 		if testCase.expect != output {
 			t.Errorf("Error. expect: %s, got: %s", testCase.expect, output)
 		}
+		reset()
 	}
 }

pkg/apimachinery/types.go

+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 apimachinery
+
+import (
+	"k8s.io/kubernetes/pkg/api/meta"
+	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/runtime"
+)
+
+// GroupMeta stores the metadata of a group.
+type GroupMeta struct {
+	// GroupVersion represents the preferred version of the group.
+	GroupVersion unversioned.GroupVersion
+
+	// GroupVersions is Group + all versions in that group.
+	GroupVersions []unversioned.GroupVersion
+
+	// Codec is the default codec for serializing output that should use
+	// the preferred version.  Use this Codec when writing to
+	// disk, a data store that is not dynamically versioned, or in tests.
+	// This codec can decode any object that the schema is aware of.
+	Codec runtime.Codec
+
+	// SelfLinker can set or get the SelfLink field of all API types.
+	// TODO: when versioning changes, make this part of each API definition.
+	// TODO(lavalamp): Combine SelfLinker & ResourceVersioner interfaces, force all uses
+	// to go through the InterfacesFor method below.
+	SelfLinker runtime.SelfLinker
+
+	// RESTMapper provides the default mapping between REST paths and the objects declared in api.Scheme and all known
+	// versions.
+	RESTMapper meta.RESTMapper
+
+	// InterfacesFor returns the default Codec and ResourceVersioner for a given version
+	// or an error if the version is not known.
+	InterfacesFor func(version unversioned.GroupVersion) (*meta.VersionInterfaces, error)
+}

pkg/apis/authorization/install/install.go

@@ -24,10 +24,10 @@ import (
 	"github.com/golang/glog"
 
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/meta"
-	"k8s.io/kubernetes/pkg/api/registered"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/apis/authorization"
 	"k8s.io/kubernetes/pkg/apis/authorization/v1beta1"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -42,8 +42,7 @@ var accessor = meta.NewAccessor()
 var availableVersions = []unversioned.GroupVersion{v1beta1.SchemeGroupVersion}
 
 func init() {
-	registered.RegisterVersions(availableVersions...)
-
+	registered.RegisterVersions(availableVersions)
 	externalVersions := []unversioned.GroupVersion{}
 	for _, v := range availableVersions {
 		if registered.IsAllowedVersion(v) {
@@ -54,6 +53,7 @@ func init() {
 		glog.V(4).Infof("No version is registered for group %v", authorization.GroupName)
 		return
 	}
+
 	if err := registered.EnableVersions(externalVersions...); err != nil {
 		glog.V(4).Infof("%v", err)
 		return
@@ -66,11 +66,13 @@ func init() {
 
 // TODO: enableVersions should be centralized rather than spread in each API
 // group.
+// We can combine registered.RegisterVersions, registered.EnableVersions and
+// registered.RegisterGroup once we have moved enableVersions there.
 func enableVersions(externalVersions []unversioned.GroupVersion) error {
 	addVersionsToScheme(externalVersions...)
 	preferredExternalVersion := externalVersions[0]
 
-	groupMeta := latest.GroupMeta{
+	groupMeta := apimachinery.GroupMeta{
 		GroupVersion:  preferredExternalVersion,
 		GroupVersions: externalVersions,
 		Codec:         runtime.CodecFor(api.Scheme, preferredExternalVersion),
@@ -79,7 +81,7 @@ func enableVersions(externalVersions []unversioned.GroupVersion) error {
 		InterfacesFor: interfacesFor,
 	}
 
-	if err := latest.RegisterGroup(groupMeta); err != nil {
+	if err := registered.RegisterGroup(groupMeta); err != nil {
 		return err
 	}
 	api.RegisterRESTMapper(groupMeta.RESTMapper)
@@ -122,7 +124,7 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
 			MetadataAccessor: accessor,
 		}, nil
 	default:
-		g, _ := latest.Group(authorization.GroupName)
+		g, _ := registered.Group(authorization.GroupName)
 		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
 	}
 }

pkg/apis/componentconfig/install/install.go

@@ -24,10 +24,10 @@ import (
 	"github.com/golang/glog"
 
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/meta"
-	"k8s.io/kubernetes/pkg/api/registered"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/apis/componentconfig"
 	"k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -42,8 +42,7 @@ var accessor = meta.NewAccessor()
 var availableVersions = []unversioned.GroupVersion{v1alpha1.SchemeGroupVersion}
 
 func init() {
-	registered.RegisterVersions(availableVersions...)
-
+	registered.RegisterVersions(availableVersions)
 	externalVersions := []unversioned.GroupVersion{}
 	for _, v := range availableVersions {
 		if registered.IsAllowedVersion(v) {
@@ -54,6 +53,7 @@ func init() {
 		glog.V(4).Infof("No version is registered for group %v", componentconfig.GroupName)
 		return
 	}
+
 	if err := registered.EnableVersions(externalVersions...); err != nil {
 		glog.V(4).Infof("%v", err)
 		return
@@ -66,11 +66,13 @@ func init() {
 
 // TODO: enableVersions should be centralized rather than spread in each API
 // group.
+// We can combine registered.RegisterVersions, registered.EnableVersions and
+// registered.RegisterGroup once we have moved enableVersions there.
 func enableVersions(externalVersions []unversioned.GroupVersion) error {
 	addVersionsToScheme(externalVersions...)
 	preferredExternalVersion := externalVersions[0]
 
-	groupMeta := latest.GroupMeta{
+	groupMeta := apimachinery.GroupMeta{
 		GroupVersion:  preferredExternalVersion,
 		GroupVersions: externalVersions,
 		Codec:         runtime.CodecFor(api.Scheme, preferredExternalVersion),
@@ -79,7 +81,7 @@ func enableVersions(externalVersions []unversioned.GroupVersion) error {
 		InterfacesFor: interfacesFor,
 	}
 
-	if err := latest.RegisterGroup(groupMeta); err != nil {
+	if err := registered.RegisterGroup(groupMeta); err != nil {
 		return err
 	}
 	api.RegisterRESTMapper(groupMeta.RESTMapper)
@@ -107,7 +109,7 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
 			MetadataAccessor: accessor,
 		}, nil
 	default:
-		g, _ := latest.Group(componentconfig.GroupName)
+		g, _ := registered.Group(componentconfig.GroupName)
 		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
 	}
 }

pkg/apis/componentconfig/install/install_test.go

@@ -20,16 +20,16 @@ import (
 	"encoding/json"
 	"testing"
 
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/apis/componentconfig"
 )
 
 func TestCodec(t *testing.T) {
 	daemonSet := componentconfig.KubeProxyConfiguration{}
-	// We do want to use package latest rather than testapi here, because we
-	// want to test if the package install and package latest work as expected.
-	data, err := latest.GroupOrDie(componentconfig.GroupName).Codec.Encode(&daemonSet)
+	// We do want to use package registered rather than testapi here, because we
+	// want to test if the package install and package registered work as expected.
+	data, err := registered.GroupOrDie(componentconfig.GroupName).Codec.Encode(&daemonSet)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -37,17 +37,17 @@ func TestCodec(t *testing.T) {
 	if err := json.Unmarshal(data, &other); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	if other.APIVersion != latest.GroupOrDie(componentconfig.GroupName).GroupVersion.String() || other.Kind != "KubeProxyConfiguration" {
+	if other.APIVersion != registered.GroupOrDie(componentconfig.GroupName).GroupVersion.String() || other.Kind != "KubeProxyConfiguration" {
 		t.Errorf("unexpected unmarshalled object %#v", other)
 	}
 }
 
 func TestInterfacesFor(t *testing.T) {
-	if _, err := latest.GroupOrDie(componentconfig.GroupName).InterfacesFor(componentconfig.SchemeGroupVersion); err == nil {
+	if _, err := registered.GroupOrDie(componentconfig.GroupName).InterfacesFor(componentconfig.SchemeGroupVersion); err == nil {
 		t.Fatalf("unexpected non-error: %v", err)
 	}
-	for i, version := range latest.GroupOrDie(componentconfig.GroupName).GroupVersions {
-		if vi, err := latest.GroupOrDie(componentconfig.GroupName).InterfacesFor(version); err != nil || vi == nil {
+	for i, version := range registered.GroupOrDie(componentconfig.GroupName).GroupVersions {
+		if vi, err := registered.GroupOrDie(componentconfig.GroupName).InterfacesFor(version); err != nil || vi == nil {
 			t.Fatalf("%d: unexpected result: %v", i, err)
 		}
 	}
@@ -57,16 +57,16 @@ func TestRESTMapper(t *testing.T) {
 	gv := unversioned.GroupVersion{Group: componentconfig.GroupName, Version: "v1alpha1"}
 	proxyGVK := gv.WithKind("KubeProxyConfiguration")
 
-	if gvk, err := latest.GroupOrDie(componentconfig.GroupName).RESTMapper.KindFor(gv.WithResource("kubeproxyconfiguration")); err != nil || gvk != proxyGVK {
+	if gvk, err := registered.GroupOrDie(componentconfig.GroupName).RESTMapper.KindFor(gv.WithResource("kubeproxyconfiguration")); err != nil || gvk != proxyGVK {
 		t.Errorf("unexpected version mapping: %v %v", gvk, err)
 	}
 
-	if m, err := latest.GroupOrDie(componentconfig.GroupName).RESTMapper.RESTMapping(proxyGVK.GroupKind(), ""); err != nil || m.GroupVersionKind != proxyGVK || m.Resource != "kubeproxyconfigurations" {
+	if m, err := registered.GroupOrDie(componentconfig.GroupName).RESTMapper.RESTMapping(proxyGVK.GroupKind(), ""); err != nil || m.GroupVersionKind != proxyGVK || m.Resource != "kubeproxyconfigurations" {
 		t.Errorf("unexpected version mapping: %#v %v", m, err)
 	}
 
-	for _, version := range latest.GroupOrDie(componentconfig.GroupName).GroupVersions {
-		mapping, err := latest.GroupOrDie(componentconfig.GroupName).RESTMapper.RESTMapping(proxyGVK.GroupKind(), version.Version)
+	for _, version := range registered.GroupOrDie(componentconfig.GroupName).GroupVersions {
+		mapping, err := registered.GroupOrDie(componentconfig.GroupName).RESTMapper.RESTMapping(proxyGVK.GroupKind(), version.Version)
 		if err != nil {
 			t.Errorf("unexpected error: %v", err)
 			continue
@@ -79,7 +79,7 @@ func TestRESTMapper(t *testing.T) {
 			t.Errorf("incorrect groupVersion: %v", mapping)
 		}
 
-		interfaces, _ := latest.GroupOrDie(componentconfig.GroupName).InterfacesFor(version)
+		interfaces, _ := registered.GroupOrDie(componentconfig.GroupName).InterfacesFor(version)
 		if mapping.Codec != interfaces.Codec {
 			t.Errorf("unexpected codec: %#v, expected: %#v", mapping, interfaces)
 		}

pkg/apis/extensions/install/install.go

@@ -24,10 +24,10 @@ import (
 	"github.com/golang/glog"
 
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/meta"
-	"k8s.io/kubernetes/pkg/api/registered"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	"k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -42,8 +42,7 @@ var accessor = meta.NewAccessor()
 var availableVersions = []unversioned.GroupVersion{v1beta1.SchemeGroupVersion}
 
 func init() {
-	registered.RegisterVersions(availableVersions...)
-
+	registered.RegisterVersions(availableVersions)
 	externalVersions := []unversioned.GroupVersion{}
 	for _, v := range availableVersions {
 		if registered.IsAllowedVersion(v) {
@@ -54,6 +53,7 @@ func init() {
 		glog.V(4).Infof("No version is registered for group %v", extensions.GroupName)
 		return
 	}
+
 	if err := registered.EnableVersions(externalVersions...); err != nil {
 		glog.V(4).Infof("%v", err)
 		return
@@ -66,11 +66,13 @@ func init() {
 
 // TODO: enableVersions should be centralized rather than spread in each API
 // group.
+// We can combine registered.RegisterVersions, registered.EnableVersions and
+// registered.RegisterGroup once we have moved enableVersions there.
 func enableVersions(externalVersions []unversioned.GroupVersion) error {
 	addVersionsToScheme(externalVersions...)
 	preferredExternalVersion := externalVersions[0]
 
-	groupMeta := latest.GroupMeta{
+	groupMeta := apimachinery.GroupMeta{
 		GroupVersion:  preferredExternalVersion,
 		GroupVersions: externalVersions,
 		Codec:         runtime.CodecFor(api.Scheme, preferredExternalVersion),
@@ -79,7 +81,7 @@ func enableVersions(externalVersions []unversioned.GroupVersion) error {
 		InterfacesFor: interfacesFor,
 	}
 
-	if err := latest.RegisterGroup(groupMeta); err != nil {
+	if err := registered.RegisterGroup(groupMeta); err != nil {
 		return err
 	}
 	api.RegisterRESTMapper(groupMeta.RESTMapper)
@@ -107,7 +109,7 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
 			MetadataAccessor: accessor,
 		}, nil
 	default:
-		g, _ := latest.Group(extensions.GroupName)
+		g, _ := registered.Group(extensions.GroupName)
 		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
 	}
 }

pkg/apis/extensions/install/install_test.go

@@ -21,8 +21,8 @@ import (
 	"testing"
 
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	"k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
 )
@@ -49,9 +49,9 @@ func TestResourceVersioner(t *testing.T) {
 
 func TestCodec(t *testing.T) {
 	daemonSet := extensions.DaemonSet{}
-	// We do want to use package latest rather than testapi here, because we
-	// want to test if the package install and package latest work as expected.
-	data, err := latest.GroupOrDie(extensions.GroupName).Codec.Encode(&daemonSet)
+	// We do want to use package registered rather than testapi here, because we
+	// want to test if the package install and package registered work as expected.
+	data, err := registered.GroupOrDie(extensions.GroupName).Codec.Encode(&daemonSet)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -59,17 +59,17 @@ func TestCodec(t *testing.T) {
 	if err := json.Unmarshal(data, &other); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	if other.APIVersion != latest.GroupOrDie(extensions.GroupName).GroupVersion.String() || other.Kind != "DaemonSet" {
+	if other.APIVersion != registered.GroupOrDie(extensions.GroupName).GroupVersion.String() || other.Kind != "DaemonSet" {
 		t.Errorf("unexpected unmarshalled object %#v", other)
 	}
 }
 
 func TestInterfacesFor(t *testing.T) {
-	if _, err := latest.GroupOrDie(extensions.GroupName).InterfacesFor(extensions.SchemeGroupVersion); err == nil {
+	if _, err := registered.GroupOrDie(extensions.GroupName).InterfacesFor(extensions.SchemeGroupVersion); err == nil {
 		t.Fatalf("unexpected non-error: %v", err)
 	}
-	for i, version := range latest.GroupOrDie(extensions.GroupName).GroupVersions {
-		if vi, err := latest.GroupOrDie(extensions.GroupName).InterfacesFor(version); err != nil || vi == nil {
+	for i, version := range registered.GroupOrDie(extensions.GroupName).GroupVersions {
+		if vi, err := registered.GroupOrDie(extensions.GroupName).InterfacesFor(version); err != nil || vi == nil {
 			t.Fatalf("%d: unexpected result: %v", i, err)
 		}
 	}
@@ -80,16 +80,16 @@ func TestRESTMapper(t *testing.T) {
 	hpaGVK := gv.WithKind("HorizontalPodAutoscaler")
 	daemonSetGVK := gv.WithKind("DaemonSet")
 
-	if gvk, err := latest.GroupOrDie(extensions.GroupName).RESTMapper.KindFor(gv.WithResource("horizontalpodautoscalers")); err != nil || gvk != hpaGVK {
+	if gvk, err := registered.GroupOrDie(extensions.GroupName).RESTMapper.KindFor(gv.WithResource("horizontalpodautoscalers")); err != nil || gvk != hpaGVK {
 		t.Errorf("unexpected version mapping: %v %v", gvk, err)
 	}
 
-	if m, err := latest.GroupOrDie(extensions.GroupName).RESTMapper.RESTMapping(daemonSetGVK.GroupKind(), ""); err != nil || m.GroupVersionKind != daemonSetGVK || m.Resource != "daemonsets" {
+	if m, err := registered.GroupOrDie(extensions.GroupName).RESTMapper.RESTMapping(daemonSetGVK.GroupKind(), ""); err != nil || m.GroupVersionKind != daemonSetGVK || m.Resource != "daemonsets" {
 		t.Errorf("unexpected version mapping: %#v %v", m, err)
 	}
 
-	for _, version := range latest.GroupOrDie(extensions.GroupName).GroupVersions {
-		mapping, err := latest.GroupOrDie(extensions.GroupName).RESTMapper.RESTMapping(hpaGVK.GroupKind(), version.Version)
+	for _, version := range registered.GroupOrDie(extensions.GroupName).GroupVersions {
+		mapping, err := registered.GroupOrDie(extensions.GroupName).RESTMapper.RESTMapping(hpaGVK.GroupKind(), version.Version)
 		if err != nil {
 			t.Errorf("unexpected error: %v", err)
 		}
@@ -101,7 +101,7 @@ func TestRESTMapper(t *testing.T) {
 			t.Errorf("incorrect groupVersion: %v", mapping)
 		}
 
-		interfaces, _ := latest.GroupOrDie(extensions.GroupName).InterfacesFor(version)
+		interfaces, _ := registered.GroupOrDie(extensions.GroupName).InterfacesFor(version)
 		if mapping.Codec != interfaces.Codec {
 			t.Errorf("unexpected codec: %#v, expected: %#v", mapping, interfaces)
 		}

pkg/apis/metrics/install/install.go

@@ -24,10 +24,10 @@ import (
 	"github.com/golang/glog"
 
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/meta"
-	"k8s.io/kubernetes/pkg/api/registered"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/apis/metrics"
 	"k8s.io/kubernetes/pkg/apis/metrics/v1alpha1"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -42,8 +42,7 @@ var accessor = meta.NewAccessor()
 var availableVersions = []unversioned.GroupVersion{v1alpha1.SchemeGroupVersion}
 
 func init() {
-	registered.RegisterVersions(availableVersions...)
-
+	registered.RegisterVersions(availableVersions)
 	externalVersions := []unversioned.GroupVersion{}
 	for _, v := range availableVersions {
 		if registered.IsAllowedVersion(v) {
@@ -54,6 +53,7 @@ func init() {
 		glog.V(4).Infof("No version is registered for group %v", metrics.GroupName)
 		return
 	}
+
 	if err := registered.EnableVersions(externalVersions...); err != nil {
 		glog.V(4).Infof("%v", err)
 		return
@@ -66,11 +66,13 @@ func init() {
 
 // TODO: enableVersions should be centralized rather than spread in each API
 // group.
+// We can combine registered.RegisterVersions, registered.EnableVersions and
+// registered.RegisterGroup once we have moved enableVersions there.
 func enableVersions(externalVersions []unversioned.GroupVersion) error {
 	addVersionsToScheme(externalVersions...)
 	preferredExternalVersion := externalVersions[0]
 
-	groupMeta := latest.GroupMeta{
+	groupMeta := apimachinery.GroupMeta{
 		GroupVersion:  preferredExternalVersion,
 		GroupVersions: externalVersions,
 		Codec:         runtime.CodecFor(api.Scheme, preferredExternalVersion),
@@ -79,7 +81,7 @@ func enableVersions(externalVersions []unversioned.GroupVersion) error {
 		InterfacesFor: interfacesFor,
 	}
 
-	if err := latest.RegisterGroup(groupMeta); err != nil {
+	if err := registered.RegisterGroup(groupMeta); err != nil {
 		return err
 	}
 	api.RegisterRESTMapper(groupMeta.RESTMapper)
@@ -107,7 +109,7 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
 			MetadataAccessor: accessor,
 		}, nil
 	default:
-		g, _ := latest.Group(metrics.GroupName)
+		g, _ := registered.Group(metrics.GroupName)
 		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
 	}
 }

pkg/apiserver/apiserver.go

@@ -33,10 +33,10 @@ import (
 	"k8s.io/kubernetes/pkg/admission"
 	"k8s.io/kubernetes/pkg/api"
 	apierrors "k8s.io/kubernetes/pkg/api/errors"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/meta"
 	"k8s.io/kubernetes/pkg/api/rest"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/apiserver/metrics"
 	"k8s.io/kubernetes/pkg/healthz"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -212,7 +212,7 @@ func logStackOnRecover(panicReason interface{}, httpWriter http.ResponseWriter)
 	glog.Errorln(buffer.String())
 
 	// TODO: make status unversioned or plumb enough of the request to deduce the requested API version
-	errorJSON(apierrors.NewGenericServerResponse(http.StatusInternalServerError, "", api.Resource(""), "", "", 0, false), latest.GroupOrDie(api.GroupName).Codec, httpWriter)
+	errorJSON(apierrors.NewGenericServerResponse(http.StatusInternalServerError, "", api.Resource(""), "", "", 0, false), registered.GroupOrDie(api.GroupName).Codec, httpWriter)
 }
 
 func InstallServiceErrorHandler(container *restful.Container, requestResolver *RequestInfoResolver, apiVersions []string) {
@@ -223,7 +223,7 @@ func InstallServiceErrorHandler(container *restful.Container, requestResolver *R
 
 func serviceErrorHandler(requestResolver *RequestInfoResolver, apiVersions []string, serviceErr restful.ServiceError, request *restful.Request, response *restful.Response) {
 	requestInfo, err := requestResolver.GetRequestInfo(request.Request)
-	codec := latest.GroupOrDie(api.GroupName).Codec
+	codec := registered.GroupOrDie(api.GroupName).Codec
 	if err == nil && requestInfo.APIVersion != "" {
 		// check if the api version is valid.
 		for _, version := range apiVersions {

pkg/apiserver/resthandler_test.go

@@ -28,8 +28,8 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	apierrors "k8s.io/kubernetes/pkg/api/errors"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util"
 	"k8s.io/kubernetes/pkg/util/strategicpatch"
@@ -155,7 +155,7 @@ func (tc *patchTestCase) Run(t *testing.T) {
 	namespace := tc.startingPod.Namespace
 	name := tc.startingPod.Name
 
-	codec := latest.GroupOrDie(api.GroupName).Codec
+	codec := registered.GroupOrDie(api.GroupName).Codec
 	admit := tc.admit
 	if admit == nil {
 		admit = func(updatedObject runtime.Object) error {

pkg/client/typed/generated/extensions/unversioned/extensions_client.go

@@ -18,7 +18,7 @@ package unversioned
 
 import (
 	"fmt"
-	latest "k8s.io/kubernetes/pkg/api/latest"
+	registered "k8s.io/kubernetes/pkg/apimachinery/registered"
 	unversioned "k8s.io/kubernetes/pkg/client/unversioned"
 )
 
@@ -95,7 +95,7 @@ func New(c *unversioned.RESTClient) *ExtensionsClient {
 
 func setConfigDefaults(config *unversioned.Config) error {
 	// if extensions group is not registered, return an error
-	g, err := latest.Group("extensions")
+	g, err := registered.Group("extensions")
 	if err != nil {
 		return err
 	}

pkg/client/typed/generated/legacy/unversioned/legacy_client.go

@@ -18,7 +18,7 @@ package unversioned
 
 import (
 	"fmt"
-	latest "k8s.io/kubernetes/pkg/api/latest"
+	registered "k8s.io/kubernetes/pkg/apimachinery/registered"
 	unversioned "k8s.io/kubernetes/pkg/client/unversioned"
 )
 
@@ -135,7 +135,7 @@ func New(c *unversioned.RESTClient) *LegacyClient {
 
 func setConfigDefaults(config *unversioned.Config) error {
 	// if legacy group is not registered, return an error
-	g, err := latest.Group("")
+	g, err := registered.Group("")
 	if err != nil {
 		return err
 	}

pkg/client/unversioned/extensions.go

@@ -19,7 +19,7 @@ package unversioned
 import (
 	"fmt"
 
-	"k8s.io/kubernetes/pkg/api/latest"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 )
 
@@ -107,7 +107,7 @@ func NewExtensionsOrDie(c *Config) *ExtensionsClient {
 
 func setExtensionsDefaults(config *Config) error {
 	// if experimental group is not registered, return an error
-	g, err := latest.Group(extensions.GroupName)
+	g, err := registered.Group(extensions.GroupName)
 	if err != nil {
 		return err
 	}
@@ -124,7 +124,7 @@ func setExtensionsDefaults(config *Config) error {
 	versionInterfaces, err := g.InterfacesFor(*config.GroupVersion)
 	if err != nil {
 		return fmt.Errorf("Extensions API group/version '%v' is not recognized (valid values: %v)",
-			config.GroupVersion, latest.GroupOrDie(extensions.GroupName).GroupVersions)
+			config.GroupVersion, registered.GroupOrDie(extensions.GroupName).GroupVersions)
 	}
 	config.Codec = versionInterfaces.Codec
 	if config.QPS == 0 {

pkg/client/unversioned/helper.go

@@ -31,8 +31,8 @@ import (
 
 	"github.com/golang/glog"
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util"
@@ -140,7 +140,7 @@ func New(c *Config) (*Client, error) {
 		return nil, err
 	}
 
-	if _, err := latest.Group(extensions.GroupName); err != nil {
+	if _, err := registered.Group(extensions.GroupName); err != nil {
 		return &Client{RESTClient: client, ExtensionsClient: nil, DiscoveryClient: discoveryClient}, nil
 	}
 	experimentalConfig := *c
@@ -371,7 +371,7 @@ func SetKubernetesDefaults(config *Config) error {
 	if len(config.UserAgent) == 0 {
 		config.UserAgent = DefaultKubernetesUserAgent()
 	}
-	g, err := latest.Group(api.GroupName)
+	g, err := registered.Group(api.GroupName)
 	if err != nil {
 		return err
 	}
@@ -380,7 +380,7 @@ func SetKubernetesDefaults(config *Config) error {
 	config.GroupVersion = &copyGroupVersion
 	versionInterfaces, err := g.InterfacesFor(*config.GroupVersion)
 	if err != nil {
-		return fmt.Errorf("API version '%v' is not recognized (valid values: %v)", *config.GroupVersion, latest.GroupOrDie(api.GroupName).GroupVersions)
+		return fmt.Errorf("API version '%v' is not recognized (valid values: %v)", *config.GroupVersion, registered.GroupOrDie(api.GroupName).GroupVersions)
 	}
 	if config.Codec == nil {
 		config.Codec = versionInterfaces.Codec
@@ -541,7 +541,7 @@ func defaultVersionFor(config *Config) *unversioned.GroupVersion {
 		// Clients default to the preferred code API version
 		// TODO: implement version negotiation (highest version supported by server)
 		// TODO this drops out when groupmeta is refactored
-		copyGroupVersion := latest.GroupOrDie(api.GroupName).GroupVersion
+		copyGroupVersion := registered.GroupOrDie(api.GroupName).GroupVersion
 		return &copyGroupVersion
 	}
 

pkg/client/unversioned/import_known_versions.go

@@ -21,7 +21,7 @@ import (
 	"fmt"
 
 	_ "k8s.io/kubernetes/pkg/api/install"
-	"k8s.io/kubernetes/pkg/api/registered"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	_ "k8s.io/kubernetes/pkg/apis/authorization/install"
 	_ "k8s.io/kubernetes/pkg/apis/componentconfig/install"
 	_ "k8s.io/kubernetes/pkg/apis/extensions/install"

pkg/controller/controller_utils.go

@@ -24,8 +24,8 @@ import (
 
 	"github.com/golang/glog"
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/validation"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/client/cache"
 	"k8s.io/kubernetes/pkg/client/record"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
@@ -259,7 +259,7 @@ func getPodsAnnotationSet(template *api.PodTemplateSpec, object runtime.Object)
 	if err != nil {
 		return desiredAnnotations, fmt.Errorf("unable to get controller reference: %v", err)
 	}
-	createdByRefJson, err := latest.GroupOrDie(api.GroupName).Codec.Encode(&api.SerializedReference{
+	createdByRefJson, err := registered.GroupOrDie(api.GroupName).Codec.Encode(&api.SerializedReference{
 		Reference: *createdByRef,
 	})
 	if err != nil {

pkg/controller/endpoint/endpoints_controller_test.go

@@ -24,9 +24,9 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	endptspkg "k8s.io/kubernetes/pkg/api/endpoints"
-	_ "k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/testapi"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	_ "k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/client/cache"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/controller"

pkg/controller/podautoscaler/horizontal_test.go

@@ -24,8 +24,8 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/pkg/api"
-	_ "k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/resource"
+	_ "k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/client/unversioned/testclient"

pkg/controller/podautoscaler/metrics/metrics_client_test.go

@@ -24,8 +24,8 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/pkg/api"
-	_ "k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/resource"
+	_ "k8s.io/kubernetes/pkg/apimachinery/registered"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/client/unversioned/testclient"
 	"k8s.io/kubernetes/pkg/runtime"

pkg/genericapiserver/genericapiserver.go

@@ -30,9 +30,9 @@ import (
 
 	"k8s.io/kubernetes/pkg/admission"
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/rest"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery"
 	"k8s.io/kubernetes/pkg/apiserver"
 	"k8s.io/kubernetes/pkg/auth/authenticator"
 	"k8s.io/kubernetes/pkg/auth/authorizer"
@@ -137,7 +137,7 @@ type APIGroupVersionOverride struct {
 
 // Info about an API group.
 type APIGroupInfo struct {
-	GroupMeta latest.GroupMeta
+	GroupMeta apimachinery.GroupMeta
 	// Info about the resources in this group. Its a map from version to resource to the storage.
 	VersionedResourcesStorageMap map[string]map[string]rest.Storage
 	// True, if this is the legacy group ("/v1").
@@ -690,7 +690,7 @@ func (s *GenericAPIServer) getAPIGroupVersion(apiGroupInfo *APIGroupInfo, groupV
 	return version, err
 }
 
-func (s *GenericAPIServer) newAPIGroupVersion(groupMeta latest.GroupMeta, groupVersion unversioned.GroupVersion) (*apiserver.APIGroupVersion, error) {
+func (s *GenericAPIServer) newAPIGroupVersion(groupMeta apimachinery.GroupMeta, groupVersion unversioned.GroupVersion) (*apiserver.APIGroupVersion, error) {
 	versionInterface, err := groupMeta.InterfacesFor(groupVersion)
 	if err != nil {
 		return nil, err

pkg/genericapiserver/genericapiserver_test.go

@@ -25,8 +25,8 @@ import (
 	"testing"
 
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/rest"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	"k8s.io/kubernetes/pkg/apiserver"
 	etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
@@ -96,8 +96,8 @@ func TestInstallAPIGroups(t *testing.T) {
 	config.APIGroupPrefix = "/apiGroupPrefix"
 
 	s := New(&config)
-	apiGroupMeta := latest.GroupOrDie(api.GroupName)
-	extensionsGroupMeta := latest.GroupOrDie(extensions.GroupName)
+	apiGroupMeta := registered.GroupOrDie(api.GroupName)
+	extensionsGroupMeta := registered.GroupOrDie(extensions.GroupName)
 	apiGroupsInfo := []APIGroupInfo{
 		{
 			// legacy group version

pkg/kubectl/cmd/convert.go

@@ -20,9 +20,9 @@ import (
 	"fmt"
 	"io"
 
-	"k8s.io/kubernetes/pkg/api/latest"
-	"k8s.io/kubernetes/pkg/api/registered"
+	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/kubectl"
 	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
 	"k8s.io/kubernetes/pkg/kubectl/resource"
@@ -95,7 +95,7 @@ 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, err = cmdutil.OutputVersion(cmd, &latest.ExternalVersions[0])
+	o.outputVersion, err = cmdutil.OutputVersion(cmd, &registered.EnabledVersionsForGroup(api.GroupName)[0])
 	if err != nil {
 		return err
 	}

pkg/kubectl/cmd/explain.go

@@ -21,8 +21,8 @@ import (
 
 	"github.com/spf13/cobra"
 
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/kubectl"
 	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
 )
@@ -85,7 +85,7 @@ func RunExplain(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []st
 	}
 
 	if len(apiVersionString) == 0 {
-		groupMeta, err := latest.Group(gvk.Group)
+		groupMeta, err := registered.Group(gvk.Group)
 		if err != nil {
 			return err
 		}

pkg/kubectl/cmd/util/clientcache.go

@@ -17,8 +17,8 @@ limitations under the License.
 package util
 
 import (
-	"k8s.io/kubernetes/pkg/api/registered"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
 )

pkg/kubectl/cmd/util/factory.go

@@ -35,9 +35,9 @@ 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"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"

pkg/kubectl/cmd/util/helpers.go

@@ -30,8 +30,8 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
 	"k8s.io/kubernetes/pkg/kubectl"
 	"k8s.io/kubernetes/pkg/kubectl/resource"
@@ -396,7 +396,7 @@ func Merge(dst runtime.Object, fragment, kind string) (runtime.Object, error) {
 		return nil, err
 	}
 
-	i, err := latest.GroupOrDie(api.GroupName).InterfacesFor(groupVersion)
+	i, err := registered.GroupOrDie(api.GroupName).InterfacesFor(groupVersion)
 	if err != nil {
 		return nil, err
 	}

pkg/kubectl/resource/mapper.go

@@ -22,7 +22,7 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/meta"
-	"k8s.io/kubernetes/pkg/api/registered"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util/yaml"
 )

pkg/kubectl/resource/result.go

@@ -21,9 +21,9 @@ import (
 	"reflect"
 
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/meta"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/runtime"
 	utilerrors "k8s.io/kubernetes/pkg/util/errors"
 	"k8s.io/kubernetes/pkg/util/sets"
@@ -221,7 +221,7 @@ func AsVersionedObject(infos []*Info, forceList bool, version string) (runtime.O
 		object = objects[0]
 	} else {
 		object = &api.List{Items: objects}
-		converted, err := tryConvert(api.Scheme, object, version, latest.GroupOrDie(api.GroupName).GroupVersion.Version)
+		converted, err := tryConvert(api.Scheme, object, version, registered.GroupOrDie(api.GroupName).GroupVersion.Version)
 		if err != nil {
 			return nil, err
 		}

pkg/kubelet/config/common.go

@@ -23,8 +23,8 @@ import (
 	"fmt"
 
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/validation"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
 	"k8s.io/kubernetes/pkg/types"
 	"k8s.io/kubernetes/pkg/util/hash"
@@ -81,7 +81,7 @@ func getSelfLink(name, namespace string) string {
 	if len(namespace) == 0 {
 		namespace = api.NamespaceDefault
 	}
-	selfLink = fmt.Sprintf("/api/"+latest.GroupOrDie(api.GroupName).GroupVersion.Version+"/pods/namespaces/%s/%s", name, namespace)
+	selfLink = fmt.Sprintf("/api/"+registered.GroupOrDie(api.GroupName).GroupVersion.Version+"/pods/namespaces/%s/%s", name, namespace)
 	return selfLink
 }
 

pkg/kubelet/config/common_test.go

@@ -21,9 +21,9 @@ import (
 	"testing"
 
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/registered"
 	"k8s.io/kubernetes/pkg/api/testapi"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/securitycontext"
 
 	"github.com/ghodss/yaml"

pkg/kubelet/dockertools/labels.go

@@ -22,7 +22,7 @@ import (
 
 	"github.com/golang/glog"
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 	"k8s.io/kubernetes/pkg/kubelet/util/format"
 	"k8s.io/kubernetes/pkg/types"
@@ -187,7 +187,7 @@ func supplyContainerInfoWithOldLabel(labels map[string]string, containerInfo *la
 		return
 	}
 	pod = &api.Pod{}
-	err := latest.GroupOrDie(api.GroupName).Codec.DecodeInto([]byte(data), pod)
+	err := registered.GroupOrDie(api.GroupName).Codec.DecodeInto([]byte(data), pod)
 	if err != nil {
 		// If the pod label can't be parsed, we should report an error
 		logError(containerInfo, kubernetesPodLabel, err)

pkg/kubelet/dockertools/labels_test.go

@@ -22,7 +22,7 @@ import (
 	"testing"
 
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 	"k8s.io/kubernetes/pkg/kubelet/util/format"
 	"k8s.io/kubernetes/pkg/util/intstr"
@@ -107,7 +107,7 @@ func TestLabels(t *testing.T) {
 	pod.DeletionGracePeriodSeconds = &deletionGracePeriod
 	pod.Spec.TerminationGracePeriodSeconds = &terminationGracePeriod
 	container.Lifecycle = lifecycle
-	data, err := latest.GroupOrDie(api.GroupName).Codec.Encode(pod)
+	data, err := registered.GroupOrDie(api.GroupName).Codec.Encode(pod)
 	if err != nil {
 		t.Fatalf("Failed to encode pod %q into string: %v", format.Pod(pod), err)
 	}

pkg/kubelet/dockertools/manager.go

@@ -36,8 +36,8 @@ import (
 	"github.com/golang/groupcache/lru"
 	cadvisorapi "github.com/google/cadvisor/info/v1"
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/client/record"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 	"k8s.io/kubernetes/pkg/kubelet/lifecycle"
@@ -655,7 +655,7 @@ func (dm *DockerManager) runContainer(
 	// TODO(random-liu): Remove this when we start to use new labels for KillContainerInPod
 	if container.Lifecycle != nil && container.Lifecycle.PreStop != nil {
 		// TODO: This is kind of hacky, we should really just encode the bits we need.
-		data, err := latest.GroupOrDie(api.GroupName).Codec.Encode(pod)
+		data, err := registered.GroupOrDie(api.GroupName).Codec.Encode(pod)
 		if err != nil {
 			glog.Errorf("Failed to encode pod: %s for prestop hook", pod.Name)
 		} else {
@@ -1432,7 +1432,7 @@ func containerAndPodFromLabels(inspect *docker.Container) (pod *api.Pod, contain
 	// the pod data may not be set
 	if body, found := labels[kubernetesPodLabel]; found {
 		pod = &api.Pod{}
-		if err = latest.GroupOrDie(api.GroupName).Codec.DecodeInto([]byte(body), pod); err == nil {
+		if err = registered.GroupOrDie(api.GroupName).Codec.DecodeInto([]byte(body), pod); err == nil {
 			name := labels[kubernetesContainerNameLabel]
 			for ix := range pod.Spec.Containers {
 				if pod.Spec.Containers[ix].Name == name {
@@ -1757,7 +1757,7 @@ func (dm *DockerManager) computePodContainerChanges(pod *api.Pod, podStatus *kub
 	}, nil
 }
 
-// updateReasonCache updates the failure reason based on the latest error.
+// updateReasonCache updates the failure reason based on the registered error.
 func (dm *DockerManager) updateReasonCache(pod *api.Pod, container *api.Container, briefError string, err error) {
 	if briefError == "" || err == nil {
 		return
@@ -2082,7 +2082,7 @@ func (dm *DockerManager) GarbageCollect(gcPolicy kubecontainer.ContainerGCPolicy
 func (dm *DockerManager) GetPodStatus(uid types.UID, name, namespace string) (*kubecontainer.PodStatus, error) {
 	podStatus := &kubecontainer.PodStatus{ID: uid, Name: name, Namespace: namespace}
 	// Now we retain restart count of container as a docker label. Each time a container
-	// restarts, pod will read the restart count from the latest dead container, increment
+	// restarts, pod will read the restart count from the registered dead container, increment
 	// it to get the new restart count, and then add a label with the new restart count on
 	// the newly started container.
 	// However, there are some limitations of this method:

pkg/kubelet/server/server.go

@@ -36,10 +36,10 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	apierrs "k8s.io/kubernetes/pkg/api/errors"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/api/v1"
 	"k8s.io/kubernetes/pkg/api/validation"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/auth/authenticator"
 	"k8s.io/kubernetes/pkg/auth/authorizer"
 	"k8s.io/kubernetes/pkg/client/unversioned/remotecommand"
@@ -462,7 +462,7 @@ func encodePods(pods []*api.Pod) (data []byte, err error) {
 	for _, pod := range pods {
 		podList.Items = append(podList.Items, *pod)
 	}
-	return latest.GroupOrDie(api.GroupName).Codec.Encode(podList)
+	return registered.GroupOrDie(api.GroupName).Codec.Encode(podList)
 }
 
 // getPods returns a list of pods bound to the Kubelet and their spec.

pkg/master/import_known_versions.go

@@ -21,7 +21,7 @@ import (
 	"fmt"
 
 	_ "k8s.io/kubernetes/pkg/api/install"
-	"k8s.io/kubernetes/pkg/api/registered"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	_ "k8s.io/kubernetes/pkg/apis/authorization/install"
 	_ "k8s.io/kubernetes/pkg/apis/componentconfig/install"
 	_ "k8s.io/kubernetes/pkg/apis/extensions/install"

pkg/master/master.go

@@ -27,9 +27,9 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/rest"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	"k8s.io/kubernetes/pkg/apiserver"
 	"k8s.io/kubernetes/pkg/genericapiserver"
@@ -179,7 +179,7 @@ func (m *Master) InstallAPIs(c *Config) {
 		// Install v1 API.
 		m.initV1ResourcesStorage(c)
 		apiGroupInfo := genericapiserver.APIGroupInfo{
-			GroupMeta: *latest.GroupOrDie(api.GroupName),
+			GroupMeta: *registered.GroupOrDie(api.GroupName),
 			VersionedResourcesStorageMap: map[string]map[string]rest.Storage{
 				"v1": m.v1ResourcesStorage,
 			},
@@ -199,7 +199,7 @@ func (m *Master) InstallAPIs(c *Config) {
 		m.thirdPartyResources = map[string]thirdPartyEntry{}
 
 		extensionResources := m.getExtensionResources(c)
-		extensionsGroupMeta := latest.GroupOrDie(extensions.GroupName)
+		extensionsGroupMeta := registered.GroupOrDie(extensions.GroupName)
 		// Update the prefered version as per StorageVersions in the config.
 		storageVersion, found := c.StorageVersions[extensionsGroupMeta.GroupVersion.Group]
 		if !found {
@@ -216,7 +216,7 @@ func (m *Master) InstallAPIs(c *Config) {
 			VersionedResourcesStorageMap: map[string]map[string]rest.Storage{
 				"v1beta1": extensionResources,
 			},
-			OptionsExternalVersion: &latest.GroupOrDie(api.GroupName).GroupVersion,
+			OptionsExternalVersion: &registered.GroupOrDie(api.GroupName).GroupVersion,
 		}
 		apiGroupsInfo = append(apiGroupsInfo, apiGroupInfo)
 
@@ -532,7 +532,7 @@ func (m *Master) thirdpartyapi(group, kind, version string) *apiserver.APIGroupV
 		strings.ToLower(kind) + "s": resourceStorage,
 	}
 
-	optionsExternalVersion := latest.GroupOrDie(api.GroupName).GroupVersion
+	optionsExternalVersion := registered.GroupOrDie(api.GroupName).GroupVersion
 
 	return &apiserver.APIGroupVersion{
 		Root:                apiRoot,
@@ -543,9 +543,9 @@ func (m *Master) thirdpartyapi(group, kind, version string) *apiserver.APIGroupV
 		Convertor: api.Scheme,
 		Typer:     api.Scheme,
 
-		Mapper:                 thirdpartyresourcedata.NewMapper(latest.GroupOrDie(extensions.GroupName).RESTMapper, kind, version, group),
-		Codec:                  thirdpartyresourcedata.NewCodec(latest.GroupOrDie(extensions.GroupName).Codec, kind),
-		Linker:                 latest.GroupOrDie(extensions.GroupName).SelfLinker,
+		Mapper:                 thirdpartyresourcedata.NewMapper(registered.GroupOrDie(extensions.GroupName).RESTMapper, kind, version, group),
+		Codec:                  thirdpartyresourcedata.NewCodec(registered.GroupOrDie(extensions.GroupName).Codec, kind),
+		Linker:                 registered.GroupOrDie(extensions.GroupName).SelfLinker,
 		Storage:                storage,
 		OptionsExternalVersion: &optionsExternalVersion,
 

pkg/registry/thirdpartyresourcedata/codec.go

@@ -24,10 +24,11 @@ import (
 	"net/url"
 	"strings"
 
-	"k8s.io/kubernetes/pkg/api/latest"
+	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/meta"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	apiutil "k8s.io/kubernetes/pkg/api/util"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	"k8s.io/kubernetes/pkg/runtime"
 )
@@ -111,7 +112,7 @@ func (t *thirdPartyResourceDataMapper) RESTMapping(gk unversioned.GroupKind, ver
 	// TODO figure out why we're doing this rewriting
 	extensionGK := unversioned.GroupKind{Group: extensions.GroupName, Kind: "ThirdPartyResourceData"}
 
-	mapping, err := t.mapper.RESTMapping(extensionGK, latest.GroupOrDie(extensions.GroupName).GroupVersion.Version)
+	mapping, err := t.mapper.RESTMapping(extensionGK, registered.GroupOrDie(extensions.GroupName).GroupVersion.Version)
 	if err != nil {
 		return nil, err
 	}
@@ -345,7 +346,7 @@ func (t *thirdPartyResourceDataCreator) New(kind unversioned.GroupVersionKind) (
 	case "ListOptions":
 		if apiutil.GetGroupVersion(t.group, t.version) == kind.GroupVersion().String() {
 			// Translate third party group to external group.
-			gvk := latest.ExternalVersions[0].WithKind(kind.Kind)
+			gvk := registered.EnabledVersionsForGroup(api.GroupName)[0].WithKind(kind.Kind)
 			return t.delegate.New(gvk)
 		}
 		return t.delegate.New(kind)

pkg/util/io/io.go

@@ -22,7 +22,7 @@ import (
 	"os"
 
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 )
 
 // LoadPodFromFile will read, decode, and return a Pod from a file.
@@ -39,7 +39,7 @@ func LoadPodFromFile(filePath string) (*api.Pod, error) {
 	}
 	pod := &api.Pod{}
 
-	if err := latest.GroupOrDie(api.GroupName).Codec.DecodeInto(podDef, pod); err != nil {
+	if err := registered.GroupOrDie(api.GroupName).Codec.DecodeInto(podDef, pod); err != nil {
 		return nil, fmt.Errorf("failed decoding file: %v", err)
 	}
 	return pod, nil
@@ -50,7 +50,7 @@ func SavePodToFile(pod *api.Pod, filePath string, perm os.FileMode) error {
 	if filePath == "" {
 		return fmt.Errorf("file path not specified")
 	}
-	data, err := latest.GroupOrDie(api.GroupName).Codec.Encode(pod)
+	data, err := registered.GroupOrDie(api.GroupName).Codec.Encode(pod)
 	if err != nil {
 		return fmt.Errorf("failed encoding pod: %v", err)
 	}

pkg/util/io/io_test.go

@@ -23,7 +23,7 @@ import (
 
 	"github.com/pborman/uuid"
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/util/io"
 	"k8s.io/kubernetes/pkg/volume"
 )
@@ -32,8 +32,8 @@ func TestSavePodToFile(t *testing.T) {
 	pod := volume.NewPersistentVolumeRecyclerPodTemplate()
 
 	// sets all default values on a pod for equality comparison after decoding from file
-	encoded, err := latest.GroupOrDie(api.GroupName).Codec.Encode(pod)
-	latest.GroupOrDie(api.GroupName).Codec.DecodeInto(encoded, pod)
+	encoded, err := registered.GroupOrDie(api.GroupName).Codec.Encode(pod)
+	registered.GroupOrDie(api.GroupName).Codec.DecodeInto(encoded, pod)
 
 	path := fmt.Sprintf("/tmp/kube-io-test-%s", uuid.New())
 	defer os.Remove(path)

test/e2e/dns.go

@@ -22,8 +22,8 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/util"
@@ -42,7 +42,7 @@ func createDNSPod(namespace, wheezyProbeCmd, jessieProbeCmd string) *api.Pod {
 	pod := &api.Pod{
 		TypeMeta: unversioned.TypeMeta{
 			Kind:       "Pod",
-			APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.String(),
+			APIVersion: registered.GroupOrDie(api.GroupName).GroupVersion.String(),
 		},
 		ObjectMeta: api.ObjectMeta{
 			Name:      "dns-test-" + string(util.NewUUID()),

test/e2e/empty_dir.go

@@ -21,8 +21,8 @@ import (
 	"path"
 
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/util"
 
 	. "github.com/onsi/ginkgo"
@@ -313,7 +313,7 @@ func testPodWithVolume(image, path string, source *api.EmptyDirVolumeSource) *ap
 	return &api.Pod{
 		TypeMeta: unversioned.TypeMeta{
 			Kind:       "Pod",
-			APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.String(),
+			APIVersion: registered.GroupOrDie(api.GroupName).GroupVersion.String(),
 		},
 		ObjectMeta: api.ObjectMeta{
 			Name: podName,

test/e2e/host_path.go

@@ -22,8 +22,8 @@ import (
 	"path"
 
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 
 	. "github.com/onsi/ginkgo"
@@ -111,7 +111,7 @@ func testPodWithHostVol(path string, source *api.HostPathVolumeSource) *api.Pod
 	return &api.Pod{
 		TypeMeta: unversioned.TypeMeta{
 			Kind:       "Pod",
-			APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.String(),
+			APIVersion: registered.GroupOrDie(api.GroupName).GroupVersion.String(),
 		},
 		ObjectMeta: api.ObjectMeta{
 			Name: podName,

test/e2e/kubelet_etc_hosts.go

@@ -20,8 +20,8 @@ import (
 	"fmt"
 	. "github.com/onsi/ginkgo"
 	api "k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"strings"
 )
@@ -143,7 +143,7 @@ func (config *KubeletManagedHostConfig) createPodSpec(podName string) *api.Pod {
 	pod := &api.Pod{
 		TypeMeta: unversioned.TypeMeta{
 			Kind:       "Pod",
-			APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.String(),
+			APIVersion: registered.GroupOrDie(api.GroupName).GroupVersion.String(),
 		},
 		ObjectMeta: api.ObjectMeta{
 			Name:      podName,
@@ -204,7 +204,7 @@ func (config *KubeletManagedHostConfig) createPodSpecWithHostNetwork(podName str
 	pod := &api.Pod{
 		TypeMeta: unversioned.TypeMeta{
 			Kind:       "Pod",
-			APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.String(),
+			APIVersion: registered.GroupOrDie(api.GroupName).GroupVersion.String(),
 		},
 		ObjectMeta: api.ObjectMeta{
 			Name:      podName,

test/e2e/kubeproxy.go

@@ -28,8 +28,8 @@ import (
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 	api "k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/util"
@@ -256,7 +256,7 @@ func (config *KubeProxyTestConfig) createNetShellPodSpec(podName string, node st
 	pod := &api.Pod{
 		TypeMeta: unversioned.TypeMeta{
 			Kind:       "Pod",
-			APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.String(),
+			APIVersion: registered.GroupOrDie(api.GroupName).GroupVersion.String(),
 		},
 		ObjectMeta: api.ObjectMeta{
 			Name:      podName,
@@ -296,7 +296,7 @@ func (config *KubeProxyTestConfig) createTestPodSpec() *api.Pod {
 	pod := &api.Pod{
 		TypeMeta: unversioned.TypeMeta{
 			Kind:       "Pod",
-			APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.String(),
+			APIVersion: registered.GroupOrDie(api.GroupName).GroupVersion.String(),
 		},
 		ObjectMeta: api.ObjectMeta{
 			Name:      testPodName,

test/e2e/pd.go

@@ -27,9 +27,9 @@ import (
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/resource"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	awscloud "k8s.io/kubernetes/pkg/cloudprovider/providers/aws"
 	gcecloud "k8s.io/kubernetes/pkg/cloudprovider/providers/gce"
@@ -413,7 +413,7 @@ func testPDPod(diskNames []string, targetHost string, readOnly bool, numContaine
 	pod := &api.Pod{
 		TypeMeta: unversioned.TypeMeta{
 			Kind:       "Pod",
-			APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.String(),
+			APIVersion: registered.GroupOrDie(api.GroupName).GroupVersion.String(),
 		},
 		ObjectMeta: api.ObjectMeta{
 			Name: "pd-test-" + string(util.NewUUID()),

test/e2e/privileged.go

@@ -22,8 +22,8 @@ import (
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"net/url"
 )
@@ -102,7 +102,7 @@ func (config *PrivilegedPodTestConfig) createPrivilegedPodSpec() *api.Pod {
 	pod := &api.Pod{
 		TypeMeta: unversioned.TypeMeta{
 			Kind:       "Pod",
-			APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.String(),
+			APIVersion: registered.GroupOrDie(api.GroupName).GroupVersion.String(),
 		},
 		ObjectMeta: api.ObjectMeta{
 			Name:      privilegedPodName,

test/e2e/resize_nodes.go

@@ -24,8 +24,8 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/util/intstr"
@@ -188,7 +188,7 @@ func rcByNameContainer(name string, replicas int, image string, labels map[strin
 	return &api.ReplicationController{
 		TypeMeta: unversioned.TypeMeta{
 			Kind:       "ReplicationController",
-			APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.String(),
+			APIVersion: registered.GroupOrDie(api.GroupName).GroupVersion.String(),
 		},
 		ObjectMeta: api.ObjectMeta{
 			Name: name,

test/e2e/util.go

@@ -35,9 +35,9 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	apierrs "k8s.io/kubernetes/pkg/api/errors"
-	"k8s.io/kubernetes/pkg/api/latest"
 	"k8s.io/kubernetes/pkg/api/resource"
 	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	"k8s.io/kubernetes/pkg/client/cache"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
@@ -2201,7 +2201,7 @@ func NewHostExecPodSpec(ns, name string) *api.Pod {
 	pod := &api.Pod{
 		TypeMeta: unversioned.TypeMeta{
 			Kind:       "Pod",
-			APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.String(),
+			APIVersion: registered.GroupOrDie(api.GroupName).GroupVersion.String(),
 		},
 		ObjectMeta: api.ObjectMeta{
 			Name:      name,