Refactor the API registration and installation

cmd/genconversion/conversion.go

@@ -25,14 +25,11 @@ import (
 	"runtime"
 
 	"k8s.io/kubernetes/pkg/api"
+	_ "k8s.io/kubernetes/pkg/api/install"
 	"k8s.io/kubernetes/pkg/api/unversioned"
-	_ "k8s.io/kubernetes/pkg/api/v1"
-	_ "k8s.io/kubernetes/pkg/apis/componentconfig"
-	_ "k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1"
-	_ "k8s.io/kubernetes/pkg/apis/extensions"
-	_ "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
-	_ "k8s.io/kubernetes/pkg/apis/metrics"
-	_ "k8s.io/kubernetes/pkg/apis/metrics/v1alpha1"
+	_ "k8s.io/kubernetes/pkg/apis/componentconfig/install"
+	_ "k8s.io/kubernetes/pkg/apis/extensions/install"
+	_ "k8s.io/kubernetes/pkg/apis/metrics/install"
 	kruntime "k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util/sets"
 

cmd/gendeepcopy/deep_copy.go

@@ -26,14 +26,11 @@ import (
 	"strings"
 
 	"k8s.io/kubernetes/pkg/api"
+	_ "k8s.io/kubernetes/pkg/api/install"
 	"k8s.io/kubernetes/pkg/api/unversioned"
-	_ "k8s.io/kubernetes/pkg/api/v1"
-	_ "k8s.io/kubernetes/pkg/apis/componentconfig"
-	_ "k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1"
-	_ "k8s.io/kubernetes/pkg/apis/extensions"
-	_ "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
-	_ "k8s.io/kubernetes/pkg/apis/metrics"
-	_ "k8s.io/kubernetes/pkg/apis/metrics/v1alpha1"
+	_ "k8s.io/kubernetes/pkg/apis/componentconfig/install"
+	_ "k8s.io/kubernetes/pkg/apis/extensions/install"
+	_ "k8s.io/kubernetes/pkg/apis/metrics/install"
 	kruntime "k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util/sets"
 

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

@@ -23,11 +23,11 @@ import (
 
 	"github.com/golang/glog"
 
+	"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/registered"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util/sets"
@@ -43,10 +43,9 @@ const groupName = "testgroup"
 var availableVersions = []unversioned.GroupVersion{{Group: groupName, Version: "v1"}}
 
 func init() {
-	registered.RegisteredGroupVersions = append(registered.RegisteredGroupVersions, v1.SchemeGroupVersion)
-
 	externalVersions := availableVersions
 	preferredExternalVersion := externalVersions[0]
+	addVersionsToScheme(externalVersions...)
 
 	groupMeta := latest.GroupMeta{
 		GroupVersion:  preferredExternalVersion,
@@ -95,3 +94,15 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
 		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
 	}
 }
+
+func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
+	// add the internal version to Scheme
+	testgroup.AddToScheme()
+	// add the enabled external versions to Scheme
+	for _, v := range externalVersions {
+		switch v {
+		case v1.SchemeGroupVersion:
+			v1.AddToScheme()
+		}
+	}
+}

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

@@ -23,8 +23,8 @@ import (
 
 var SchemeGroupVersion = unversioned.GroupVersion{Group: "testgroup", Version: ""}
 
-func init() {
-	// Register the API.
+func AddToScheme() {
+	// Add the API to Scheme.
 	addKnownTypes()
 }
 

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

@@ -27,8 +27,8 @@ var SchemeGroupVersion = unversioned.GroupVersion{Group: "testgroup", Version: "
 
 var Codec = runtime.CodecFor(api.Scheme, SchemeGroupVersion)
 
-func init() {
-	// Register the API.
+func AddToScheme() {
+	// Add the API to Scheme.
 	addKnownTypes()
 }
 

contrib/mesos/pkg/podutil/gzip.go

@@ -23,6 +23,7 @@ import (
 	"io/ioutil"
 
 	"k8s.io/kubernetes/pkg/api"
+	_ "k8s.io/kubernetes/pkg/api/install"
 	"k8s.io/kubernetes/pkg/api/v1"
 )
 

docs/admin/kube-apiserver.md

@@ -100,7 +100,7 @@ kube-apiserver
       --service-node-port-range=: A port range to reserve for services with NodePort visibility.  Example: '30000-32767'.  Inclusive at both ends of the range.
       --ssh-keyfile="": If non-empty, use secure SSH proxy to the nodes, using this user keyfile
       --ssh-user="": If non-empty, use secure SSH proxy to the nodes, using this user name
-      --storage-versions="componentconfig/v1alpha1,extensions/v1beta1,v1": The versions to store resources with. Different groups may be stored in different versions. Specified in the format "group1/version1,group2/version2...". This flag expects a complete list of storage versions of ALL groups registered in the server. It defaults to a list of preferred versions of all registered groups, which is derived from the KUBE_API_VERSIONS environment variable.
+      --storage-versions="componentconfig/v1alpha1,extensions/v1beta1,metrics/v1alpha1,v1": The versions to store resources with. Different groups may be stored in different versions. Specified in the format "group1/version1,group2/version2...". This flag expects a complete list of storage versions of ALL groups registered in the server. It defaults to a list of preferred versions of all registered groups, which is derived from the KUBE_API_VERSIONS environment variable.
       --tls-cert-file="": File containing x509 Certificate for HTTPS.  (CA cert, if any, concatenated after server cert). If HTTPS serving is enabled, and --tls-cert-file and --tls-private-key-file are not provided, a self-signed certificate and key are generated for the public address and saved to /var/run/kubernetes.
       --tls-private-key-file="": File containing x509 private key matching --tls-cert-file.
       --token-auth-file="": If set, the file that will be used to secure the secure port of the API server via token authentication.

pkg/api/install/install.go

@@ -25,10 +25,10 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/latest"
+	"k8s.io/kubernetes/pkg/api/registered"
 	"k8s.io/kubernetes/pkg/util/sets"
 
 	"k8s.io/kubernetes/pkg/api/meta"
-	"k8s.io/kubernetes/pkg/api/registered"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/api/v1"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -42,20 +42,32 @@ var accessor = meta.NewAccessor()
 var availableVersions = []unversioned.GroupVersion{v1.SchemeGroupVersion}
 
 func init() {
+	registered.RegisterVersions(availableVersions...)
+
 	externalVersions := []unversioned.GroupVersion{}
-	for _, allowedVersion := range registered.GroupVersionsForGroup(api.GroupName) {
-		for _, externalVersion := range availableVersions {
-			if externalVersion == allowedVersion {
-				externalVersions = append(externalVersions, externalVersion)
-			}
+	for _, v := range availableVersions {
+		if registered.IsAllowedVersion(v) {
+			externalVersions = append(externalVersions, v)
 		}
 	}
-
 	if len(externalVersions) == 0 {
 		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
+	}
+	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.
+func enableVersions(externalVersions []unversioned.GroupVersion) error {
+	addVersionsToScheme(externalVersions...)
 	preferredExternalVersion := externalVersions[0]
 
 	groupMeta := latest.GroupMeta{
@@ -68,11 +80,10 @@ func init() {
 	}
 
 	if err := latest.RegisterGroup(groupMeta); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
+		return err
 	}
-
 	api.RegisterRESTMapper(groupMeta.RESTMapper)
+	return nil
 }
 
 // userResources is a group of resources mostly used by a kubectl user
@@ -128,3 +139,19 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
 		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
 	}
 }
+
+func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
+	// add the internal version to Scheme
+	api.AddToScheme()
+	// add the enabled external versions to Scheme
+	for _, v := range externalVersions {
+		if !registered.IsEnabledVersion(v) {
+			glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
+			continue
+		}
+		switch v {
+		case v1.SchemeGroupVersion:
+			v1.AddToScheme()
+		}
+	}
+}

pkg/api/register.go

@@ -41,7 +41,7 @@ func Resource(resource string) unversioned.GroupResource {
 	return SchemeGroupVersion.WithResource(resource).GroupResource()
 }
 
-func init() {
+func AddToScheme() {
 	Scheme.AddKnownTypes(SchemeGroupVersion,
 		&Pod{},
 		&PodList{},
@@ -86,7 +86,7 @@ func init() {
 		&RangeAllocation{},
 	)
 
-	// Register Unversioned types
+	// Add the Unversioned types to Scheme.
 	// TODO this should not be done here
 	Scheme.AddKnownTypes(SchemeGroupVersion, &unversioned.ExportOptions{})
 	Scheme.AddKnownTypes(SchemeGroupVersion, &unversioned.Status{})

pkg/api/registered/registered.go

@@ -18,6 +18,7 @@ limitations under the License.
 package registered
 
 import (
+	"fmt"
 	"os"
 	"strings"
 
@@ -25,71 +26,129 @@ import (
 	"k8s.io/kubernetes/pkg/api/unversioned"
 )
 
-// List of registered API versions.
-// The list is in the order of most preferred to the least.
-var RegisteredGroupVersions []unversioned.GroupVersion
+var (
+	// registeredVersions represents all registered API versions. Please call
+	// RegisterVersions() to add registered versions.
+	registeredVersions = map[unversioned.GroupVersion]struct{}{}
+
+	// enabledVersions represents all enabled API versions. It should be a
+	// subset of registeredVersions. Please call EnableVersions() to add
+	// enabled versions.
+	enabledVersions = map[unversioned.GroupVersion]struct{}{}
+
+	// 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
+	// Scheme.
+	envRequestedVersions = map[unversioned.GroupVersion]struct{}{}
+)
 
 func init() {
-	validGroupVersions := map[unversioned.GroupVersion]bool{
-		unversioned.GroupVersion{Group: "", Version: "v1"}:                      true,
-		unversioned.GroupVersion{Group: "extensions", Version: "v1beta1"}:       true,
-		unversioned.GroupVersion{Group: "componentconfig", Version: "v1alpha1"}: true,
-		unversioned.GroupVersion{Group: "metrics", Version: "v1alpha1"}:         true,
-	}
-
-	// The default list of supported api versions, in order of most preferred to the least.
-	supportedVersions := []unversioned.GroupVersion{
-		{Group: "", Version: "v1"},
-		{Group: "extensions", Version: "v1beta1"},
-		{Group: "componentconfig", Version: "v1alpha1"},
-	}
-
-	// Env var KUBE_API_VERSIONS is a comma separated list of API versions that should be registered in the scheme.
-	// The versions should be in the order of most preferred to the least.
-	userRequestedVersions := os.Getenv("KUBE_API_VERSIONS")
-	if len(userRequestedVersions) != 0 {
-		// reset the supported versions
-		supportedVersions = []unversioned.GroupVersion{}
-		for _, version := range strings.Split(userRequestedVersions, ",") {
+	// Env var KUBE_API_VERSIONS is a comma separated list of API versions that
+	// should be registered in the scheme.
+	kubeAPIVersions := os.Getenv("KUBE_API_VERSIONS")
+	if len(kubeAPIVersions) != 0 {
+		for _, version := range strings.Split(kubeAPIVersions, ",") {
 			gv, err := unversioned.ParseGroupVersion(version)
 			if err != nil {
-				glog.Fatalf("invalid api version: %s in KUBE_API_VERSIONS: %s. List of valid API versions: %v",
-					version, os.Getenv("KUBE_API_VERSIONS"), validGroupVersions)
+				glog.Fatalf("invalid api version: %s in KUBE_API_VERSIONS: %s.",
+					version, os.Getenv("KUBE_API_VERSIONS"))
 			}
-
-			// Verify that the version is valid.
-			valid, ok := validGroupVersions[gv]
-			if !ok || !valid {
-				// Not a valid API version.
-				glog.Fatalf("invalid api version: %s in KUBE_API_VERSIONS: %s. List of valid API versions: %v",
-					version, os.Getenv("KUBE_API_VERSIONS"), validGroupVersions)
-			}
-
-			supportedVersions = append(supportedVersions, gv)
+			envRequestedVersions[gv] = struct{}{}
 		}
 	}
-
-	RegisteredGroupVersions = supportedVersions
 }
 
-// Returns true if the given api version is one of the registered api versions.
-func IsRegisteredAPIGroupVersion(gv unversioned.GroupVersion) bool {
-	for _, currGV := range RegisteredGroupVersions {
-		if currGV == gv {
-			return true
-		}
+// RegisterVersions add the versions the registeredVersions.
+func RegisterVersions(versions ...unversioned.GroupVersion) {
+	for _, v := range versions {
+		registeredVersions[v] = struct{}{}
 	}
-	return false
 }
 
-// GroupVersionsForGroup returns the registered versions of a group in the form
-// of "group/version".
-func GroupVersionsForGroup(group string) []unversioned.GroupVersion {
-	ret := []unversioned.GroupVersion{}
-	for _, v := range RegisteredGroupVersions {
+// EnableVersions add the versions to the enabledVersions. The caller of this
+// function is responsible to add the version to 'latest' and 'Scheme'.
+func EnableVersions(versions ...unversioned.GroupVersion) error {
+	var unregisteredVersions []unversioned.GroupVersion
+	for _, v := range versions {
+		if _, found := registeredVersions[v]; !found {
+			unregisteredVersions = append(unregisteredVersions, v)
+		}
+		enabledVersions[v] = struct{}{}
+	}
+	if len(unregisteredVersions) != 0 {
+		return fmt.Errorf("Please register versions before enabling them: %v", unregisteredVersions)
+	}
+	return nil
+}
+
+// IsAllowedVersion returns if the version is allowed by the KUBE_API_VERSIONS
+// environment variable. If the environment variable is empty, then it always
+// returns true.
+func IsAllowedVersion(v unversioned.GroupVersion) bool {
+	if len(envRequestedVersions) == 0 {
+		return true
+	}
+	_, found := envRequestedVersions[v]
+	return found
+}
+
+// IsEnabledVersion returns if a version is enabled.
+func IsEnabledVersion(v unversioned.GroupVersion) bool {
+	_, found := enabledVersions[v]
+	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 {
+		ret = append(ret, v)
+	}
+	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 {
 		if v.Group == group {
 			ret = append(ret, v)
 		}
 	}
-	return ret
+	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)
+		}
+	}
+	return
+}
+
+// ValidateEnvRequestedVersions returns a list of versions that are requested in
+// the KUBE_API_VERSIONS environment variable, but not enabled.
+func ValidateEnvRequestedVersions() []unversioned.GroupVersion {
+	var missingVersions []unversioned.GroupVersion
+	for v := range envRequestedVersions {
+		if _, found := enabledVersions[v]; !found {
+			missingVersions = append(missingVersions, v)
+		}
+	}
+	return missingVersions
 }

pkg/api/testing/fuzzer.go

@@ -25,8 +25,8 @@ import (
 
 	docker "github.com/fsouza/go-dockerclient"
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/registered"
 	"k8s.io/kubernetes/pkg/api/resource"
+	"k8s.io/kubernetes/pkg/api/testapi"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	"k8s.io/kubernetes/pkg/fields"
@@ -311,7 +311,10 @@ func FuzzerFor(t *testing.T, version string, src rand.Source) *fuzz.Fuzzer {
 				ev.ValueFrom = &api.EnvVarSource{}
 				ev.ValueFrom.FieldRef = &api.ObjectFieldSelector{}
 
-				versions := registered.RegisteredGroupVersions
+				var versions []unversioned.GroupVersion
+				for _, testGroup := range testapi.Groups {
+					versions = append(versions, *testGroup.GroupVersion())
+				}
 
 				ev.ValueFrom.FieldRef.APIVersion = versions[c.Rand.Intn(len(versions))].String()
 				ev.ValueFrom.FieldRef.FieldPath = c.RandString()

pkg/api/v1/register.go

@@ -18,7 +18,6 @@ package v1
 
 import (
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/registered"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/runtime"
 )
@@ -32,13 +31,8 @@ var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: "v1
 // Codec encodes internal objects to the v1 scheme
 var Codec = runtime.CodecFor(api.Scheme, SchemeGroupVersion)
 
-func init() {
-	// Check if v1 is in the list of supported API versions.
-	if !registered.IsRegisteredAPIGroupVersion(SchemeGroupVersion) {
-		return
-	}
-
-	// Register the API.
+func AddToScheme() {
+	// Add the API to Scheme.
 	addKnownTypes()
 	addConversionFuncs()
 	addDefaultingFuncs()

pkg/apis/componentconfig/install/install.go

@@ -42,20 +42,32 @@ var accessor = meta.NewAccessor()
 var availableVersions = []unversioned.GroupVersion{v1alpha1.SchemeGroupVersion}
 
 func init() {
+	registered.RegisterVersions(availableVersions...)
+
 	externalVersions := []unversioned.GroupVersion{}
-	for _, allowedVersion := range registered.GroupVersionsForGroup(componentconfig.GroupName) {
-		for _, externalVersion := range availableVersions {
-			if externalVersion == allowedVersion {
-				externalVersions = append(externalVersions, externalVersion)
-			}
+	for _, v := range availableVersions {
+		if registered.IsAllowedVersion(v) {
+			externalVersions = append(externalVersions, v)
 		}
 	}
-
 	if len(externalVersions) == 0 {
 		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
+	}
+	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.
+func enableVersions(externalVersions []unversioned.GroupVersion) error {
+	addVersionsToScheme(externalVersions...)
 	preferredExternalVersion := externalVersions[0]
 
 	groupMeta := latest.GroupMeta{
@@ -68,11 +80,10 @@ func init() {
 	}
 
 	if err := latest.RegisterGroup(groupMeta); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
+		return err
 	}
-
 	api.RegisterRESTMapper(groupMeta.RESTMapper)
+	return nil
 }
 
 func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
@@ -105,3 +116,19 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
 		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
 	}
 }
+
+func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
+	// add the internal version to Scheme
+	componentconfig.AddToScheme()
+	// add the enabled external versions to Scheme
+	for _, v := range externalVersions {
+		if !registered.IsEnabledVersion(v) {
+			glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
+			continue
+		}
+		switch v {
+		case v1alpha1.SchemeGroupVersion:
+			v1alpha1.AddToScheme()
+		}
+	}
+}

pkg/apis/componentconfig/register.go

@@ -21,7 +21,7 @@ import (
 	"k8s.io/kubernetes/pkg/api/unversioned"
 )
 
-func init() {
+func AddToScheme() {
 	addKnownTypes()
 }
 

pkg/apis/componentconfig/v1alpha1/register.go

@@ -30,7 +30,7 @@ var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: "v1
 
 var Codec = runtime.CodecFor(api.Scheme, SchemeGroupVersion)
 
-func init() {
+func AddToScheme() {
 	addKnownTypes()
 	addDefaultingFuncs()
 }

pkg/apis/extensions/install/install.go

@@ -42,20 +42,32 @@ var accessor = meta.NewAccessor()
 var availableVersions = []unversioned.GroupVersion{v1beta1.SchemeGroupVersion}
 
 func init() {
+	registered.RegisterVersions(availableVersions...)
+
 	externalVersions := []unversioned.GroupVersion{}
-	for _, allowedVersion := range registered.GroupVersionsForGroup(extensions.GroupName) {
-		for _, externalVersion := range availableVersions {
-			if externalVersion == allowedVersion {
-				externalVersions = append(externalVersions, externalVersion)
-			}
+	for _, v := range availableVersions {
+		if registered.IsAllowedVersion(v) {
+			externalVersions = append(externalVersions, v)
 		}
 	}
-
 	if len(externalVersions) == 0 {
 		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
+	}
+	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.
+func enableVersions(externalVersions []unversioned.GroupVersion) error {
+	addVersionsToScheme(externalVersions...)
 	preferredExternalVersion := externalVersions[0]
 
 	groupMeta := latest.GroupMeta{
@@ -68,11 +80,10 @@ func init() {
 	}
 
 	if err := latest.RegisterGroup(groupMeta); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
+		return err
 	}
-
 	api.RegisterRESTMapper(groupMeta.RESTMapper)
+	return nil
 }
 
 func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
@@ -105,3 +116,19 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
 		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
 	}
 }
+
+func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
+	// add the internal version to Scheme
+	extensions.AddToScheme()
+	// add the enabled external versions to Scheme
+	for _, v := range externalVersions {
+		if !registered.IsEnabledVersion(v) {
+			glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
+			continue
+		}
+		switch v {
+		case v1beta1.SchemeGroupVersion:
+			v1beta1.AddToScheme()
+		}
+	}
+}

pkg/apis/extensions/register.go

@@ -37,8 +37,8 @@ func Resource(resource string) unversioned.GroupResource {
 	return SchemeGroupVersion.WithResource(resource).GroupResource()
 }
 
-func init() {
-	// Register the API.
+func AddToScheme() {
+	// Add the API to Scheme.
 	addKnownTypes()
 }
 

pkg/apis/extensions/v1beta1/defaults_test.go

@@ -14,14 +14,17 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package v1beta1
+package v1beta1_test
 
 import (
 	"reflect"
 	"testing"
 
 	"k8s.io/kubernetes/pkg/api"
+	_ "k8s.io/kubernetes/pkg/api/install"
 	"k8s.io/kubernetes/pkg/api/v1"
+	_ "k8s.io/kubernetes/pkg/apis/extensions/install"
+	. "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util/intstr"
 )

pkg/apis/extensions/v1beta1/register.go

@@ -31,7 +31,7 @@ var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: "v1
 
 var Codec = runtime.CodecFor(api.Scheme, SchemeGroupVersion)
 
-func init() {
+func AddToScheme() {
 	addKnownTypes()
 	addDefaultingFuncs()
 	addConversionFuncs()

pkg/apis/metrics/install/install.go

@@ -42,20 +42,32 @@ var accessor = meta.NewAccessor()
 var availableVersions = []unversioned.GroupVersion{v1alpha1.SchemeGroupVersion}
 
 func init() {
+	registered.RegisterVersions(availableVersions...)
+
 	externalVersions := []unversioned.GroupVersion{}
-	for _, allowedVersion := range registered.GroupVersionsForGroup(metrics.GroupName) {
-		for _, externalVersion := range availableVersions {
-			if externalVersion == allowedVersion {
-				externalVersions = append(externalVersions, externalVersion)
-			}
+	for _, v := range availableVersions {
+		if registered.IsAllowedVersion(v) {
+			externalVersions = append(externalVersions, v)
 		}
 	}
-
 	if len(externalVersions) == 0 {
 		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
+	}
+	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.
+func enableVersions(externalVersions []unversioned.GroupVersion) error {
+	addVersionsToScheme(externalVersions...)
 	preferredExternalVersion := externalVersions[0]
 
 	groupMeta := latest.GroupMeta{
@@ -68,11 +80,10 @@ func init() {
 	}
 
 	if err := latest.RegisterGroup(groupMeta); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
+		return err
 	}
-
 	api.RegisterRESTMapper(groupMeta.RESTMapper)
+	return nil
 }
 
 func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
@@ -105,3 +116,19 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
 		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
 	}
 }
+
+func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
+	// add the internal version to Scheme
+	metrics.AddToScheme()
+	// add the enabled external versions to Scheme
+	for _, v := range externalVersions {
+		if !registered.IsEnabledVersion(v) {
+			glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
+			continue
+		}
+		switch v {
+		case v1alpha1.SchemeGroupVersion:
+			v1alpha1.AddToScheme()
+		}
+	}
+}

pkg/apis/metrics/register.go

@@ -21,8 +21,8 @@ import (
 	"k8s.io/kubernetes/pkg/api/unversioned"
 )
 
-func init() {
-	// Register the API.
+func AddToScheme() {
+	// Add the API to Scheme.
 	addKnownTypes()
 }
 

pkg/apis/metrics/v1alpha1/register.go

@@ -31,8 +31,8 @@ var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: "v1
 
 var Codec = runtime.CodecFor(api.Scheme, SchemeGroupVersion)
 
-func init() {
-	// Register the API.
+func AddToScheme() {
+	// Add the API to Scheme.
 	addKnownTypes()
 }
 

pkg/client/unversioned/import_known_versions.go

@@ -18,8 +18,17 @@ package unversioned
 
 // These imports are the API groups the client will support.
 import (
+	"fmt"
+
 	_ "k8s.io/kubernetes/pkg/api/install"
+	"k8s.io/kubernetes/pkg/api/registered"
 	_ "k8s.io/kubernetes/pkg/apis/componentconfig/install"
 	_ "k8s.io/kubernetes/pkg/apis/extensions/install"
 	_ "k8s.io/kubernetes/pkg/apis/metrics/install"
 )
+
+func init() {
+	if missingVersions := registered.ValidateEnvRequestedVersions(); len(missingVersions) != 0 {
+		panic(fmt.Sprintf("KUBE_API_VERSIONS contains versions that are not installed: %q.", missingVersions))
+	}
+}

pkg/client/unversioned/testclient/testclient.go

@@ -296,7 +296,7 @@ func (c *Fake) ServerAPIVersions() (*unversioned.APIVersions, error) {
 
 	c.Invokes(action, nil)
 	gvStrings := []string{}
-	for _, gv := range registered.RegisteredGroupVersions {
+	for _, gv := range registered.EnabledVersions() {
 		gvStrings = append(gvStrings, gv.String())
 	}
 	return &unversioned.APIVersions{Versions: gvStrings}, nil

pkg/kubectl/cmd/convert.go

@@ -99,7 +99,7 @@ func (o *ConvertOptions) Complete(f *cmdutil.Factory, out io.Writer, cmd *cobra.
 	if err != nil {
 		return err
 	}
-	if !registered.IsRegisteredAPIGroupVersion(o.outputVersion) {
+	if !registered.IsEnabledVersion(o.outputVersion) {
 		cmdutil.UsageError(cmd, "'%s' is not a registered version.", o.outputVersion)
 	}
 

pkg/kubectl/cmd/util/clientcache.go

@@ -72,7 +72,7 @@ func (c *ClientCache) ClientConfigForVersion(version *unversioned.GroupVersion)
 		preferredGV = &versionCopy
 	}
 
-	negotiatedVersion, err := client.NegotiateVersion(c.defaultClient, &config, preferredGV, registered.RegisteredGroupVersions)
+	negotiatedVersion, err := client.NegotiateVersion(c.defaultClient, &config, preferredGV, registered.EnabledVersions())
 	if err != nil {
 		return nil, err
 	}

pkg/kubectl/cmd/util/factory.go

@@ -531,8 +531,8 @@ func (c *clientSwaggerSchema) ValidateBytes(data []byte) error {
 	if err != nil {
 		return err
 	}
-	if ok := registered.IsRegisteredAPIGroupVersion(gvk.GroupVersion()); !ok {
-		return fmt.Errorf("API version %q isn't supported, only supports API versions %q", gvk.GroupVersion().String(), registered.RegisteredGroupVersions)
+	if ok := registered.IsEnabledVersion(gvk.GroupVersion()); !ok {
+		return fmt.Errorf("API version %q isn't supported, only supports API versions %q", gvk.GroupVersion().String(), registered.EnabledVersions())
 	}
 	if gvk.Group == extensions.GroupName {
 		if c.c.ExtensionsClient == nil {

pkg/kubectl/resource/mapper.go

@@ -48,8 +48,8 @@ func (m *Mapper) InfoForData(data []byte, source string) (*Info, error) {
 	if err != nil {
 		return nil, fmt.Errorf("unable to get type info from %q: %v", source, err)
 	}
-	if ok := registered.IsRegisteredAPIGroupVersion(gvk.GroupVersion()); !ok {
-		return nil, fmt.Errorf("API version %q in %q isn't supported, only supports API versions %q", gvk.GroupVersion().String(), source, registered.RegisteredGroupVersions)
+	if ok := registered.IsEnabledVersion(gvk.GroupVersion()); !ok {
+		return nil, fmt.Errorf("API version %q in %q isn't supported, only supports API versions %q", gvk.GroupVersion().String(), source, registered.EnabledVersions())
 	}
 	if gvk.Kind == "" {
 		return nil, fmt.Errorf("kind not set in %q", source)

pkg/kubelet/config/common_test.go

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

pkg/master/import_known_versions.go

@@ -18,7 +18,16 @@ package master
 
 // These imports are the API groups the API server will support.
 import (
+	"fmt"
+
 	_ "k8s.io/kubernetes/pkg/api/install"
+	"k8s.io/kubernetes/pkg/api/registered"
 	_ "k8s.io/kubernetes/pkg/apis/componentconfig/install"
 	_ "k8s.io/kubernetes/pkg/apis/extensions/install"
 )
+
+func init() {
+	if missingVersions := registered.ValidateEnvRequestedVersions(); len(missingVersions) != 0 {
+		panic(fmt.Sprintf("KUBE_API_VERSIONS contains versions that are not installed: %q.", missingVersions))
+	}
+}