@@ -9,6 +9,7 @@ import (

 	"strings"

 	"time"

+	"k8s.io/kubernetes/pkg/api/unversioned"

 	kclient "k8s.io/kubernetes/pkg/client/unversioned"

 	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"

 	kubeletclient "k8s.io/kubernetes/pkg/kubelet/client"

@@ -517,3 +518,15 @@ func GetEnabledAPIVersionsForGroup(config KubernetesMasterConfig, apiGroup strin

 	return enabledVersions

 }

+

+// GetDisabledAPIVersionsForGroup returns the list of API Versions that are disabled for that group

+func GetDisabledAPIVersionsForGroup(config KubernetesMasterConfig, apiGroup string) []string {

+	allowedVersions := sets.NewString(KubeAPIGroupsToAllowedVersions[apiGroup]...)

+	enabledVersions := sets.NewString(GetEnabledAPIVersionsForGroup(config, apiGroup)...)

+	return allowedVersions.Difference(enabledVersions).List()

+}

+

+func HasKubernetesAPIVersion(config KubernetesMasterConfig, groupVersion unversioned.GroupVersion) bool {

+	enabledVersions := GetEnabledAPIVersionsForGroup(config, groupVersion.Group)

+	return sets.NewString(enabledVersions...).Has(groupVersion.Version)

+}

@@ -10,10 +10,16 @@ import (

 	"github.com/golang/glog"

 	osclient "github.com/openshift/origin/pkg/client"

+	configapi "github.com/openshift/origin/pkg/cmd/server/api"

+

 	kctrlmgr "k8s.io/kubernetes/cmd/kube-controller-manager/app"

 	kapi "k8s.io/kubernetes/pkg/api"

+	"k8s.io/kubernetes/pkg/api/unversioned"

+	"k8s.io/kubernetes/pkg/api/v1"

+	extv1beta1 "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"

 	"k8s.io/kubernetes/pkg/client/record"

 	client "k8s.io/kubernetes/pkg/client/unversioned"

+	"k8s.io/kubernetes/pkg/controller"

 	endpointcontroller "k8s.io/kubernetes/pkg/controller/endpoint"

 	jobcontroller "k8s.io/kubernetes/pkg/controller/job"

 	namespacecontroller "k8s.io/kubernetes/pkg/controller/namespace"

@@ -55,11 +61,11 @@ func (c *MasterConfig) InstallAPI(container *restful.Container) []string {

 	_ = master.New(c.Master)

 	messages := []string{}

-	if !c.Master.DisableV1 {

+	if configapi.HasKubernetesAPIVersion(c.Options, v1.SchemeGroupVersion) {

 		messages = append(messages, fmt.Sprintf("Started Kubernetes API at %%s%s", KubeAPIPrefixV1))

 	}

-	if c.Master.EnableExp {

+	if configapi.HasKubernetesAPIVersion(c.Options, extv1beta1.SchemeGroupVersion) {

 		messages = append(messages, fmt.Sprintf("Started Kubernetes API Extensions at %%s%s", KubeAPIExtensionsPrefixV1beta1))

 	}

@@ -68,10 +74,15 @@ func (c *MasterConfig) InstallAPI(container *restful.Container) []string {

 // RunNamespaceController starts the Kubernetes Namespace Manager

 func (c *MasterConfig) RunNamespaceController() {

-	// we now have several of the kube "experimental" pieces enabled in Origin, so this needs to be

-	// enabled whenever we have the "experimental" APIs enabled.

-	experimentalMode := c.Master.EnableExp

-	namespaceController := namespacecontroller.NewNamespaceController(c.KubeClient, experimentalMode, c.ControllerManager.NamespaceSyncPeriod)

+	versions := []string{}

+	for _, version := range configapi.GetEnabledAPIVersionsForGroup(c.Options, configapi.APIGroupKube) {

+		versions = append(versions, unversioned.GroupVersion{Group: configapi.APIGroupKube, Version: version}.String())

+	}

+	for _, version := range configapi.GetEnabledAPIVersionsForGroup(c.Options, configapi.APIGroupExtensions) {

+		versions = append(versions, unversioned.GroupVersion{Group: configapi.APIGroupExtensions, Version: version}.String())

+	}

+	apiVersions := &unversioned.APIVersions{Versions: versions}

+	namespaceController := namespacecontroller.NewNamespaceController(c.KubeClient, apiVersions, c.ControllerManager.NamespaceSyncPeriod)

 	namespaceController.Run()

 }

@@ -11,19 +11,23 @@ import (

 	"github.com/golang/glog"

+	etcdclient "github.com/coreos/go-etcd/etcd"

+

 	"k8s.io/kubernetes/cmd/kube-apiserver/app"

 	cmapp "k8s.io/kubernetes/cmd/kube-controller-manager/app"

 	"k8s.io/kubernetes/pkg/admission"

 	kapi "k8s.io/kubernetes/pkg/api"

 	kapilatest "k8s.io/kubernetes/pkg/api/latest"

+	"k8s.io/kubernetes/pkg/api/unversioned"

 	"k8s.io/kubernetes/pkg/apiserver"

 	kclient "k8s.io/kubernetes/pkg/client/unversioned"

 	"k8s.io/kubernetes/pkg/cloudprovider"

 	kubeletclient "k8s.io/kubernetes/pkg/kubelet/client"

 	"k8s.io/kubernetes/pkg/master"

+	"k8s.io/kubernetes/pkg/storage"

+	etcdstorage "k8s.io/kubernetes/pkg/storage/etcd"

 	"k8s.io/kubernetes/pkg/util"

 	kerrors "k8s.io/kubernetes/pkg/util/errors"

-	"k8s.io/kubernetes/pkg/util/sets"

 	"k8s.io/kubernetes/pkg/util/intstr"

 	saadmit "k8s.io/kubernetes/plugin/pkg/admission/serviceaccount"

@@ -186,9 +190,9 @@ func BuildKubernetesMasterConfig(options configapi.MasterConfig, requestContextM

 	storageVersions := map[string]string{}

 	enabledKubeVersions := configapi.GetEnabledAPIVersionsForGroup(*options.KubernetesMasterConfig, configapi.APIGroupKube)

-	enabledKubeVersionSet := sets.NewString(enabledKubeVersions...)

 	if len(enabledKubeVersions) > 0 {

-		databaseStorage, err := master.NewEtcdStorage(etcdClient, kapilatest.InterfacesForLegacyGroup, options.EtcdStorageConfig.KubernetesStorageVersion, options.EtcdStorageConfig.KubernetesStoragePrefix)

+		kubeStorageVersion := unversioned.GroupVersion{Group: configapi.APIGroupKube, Version: options.EtcdStorageConfig.KubernetesStorageVersion}

+		databaseStorage, err := NewEtcdStorage(etcdClient, kubeStorageVersion, options.EtcdStorageConfig.KubernetesStoragePrefix)

 		if err != nil {

 			return nil, fmt.Errorf("Error setting up Kubernetes server storage: %v", err)

 		}

@@ -203,7 +207,7 @@ func BuildKubernetesMasterConfig(options configapi.MasterConfig, requestContextM

 			return nil, fmt.Errorf("Error setting up Kubernetes extensions server storage: %v", err)

 		}

 		// TODO expose storage version options for api groups

-		databaseStorage, err := master.NewEtcdStorage(etcdClient, groupMeta.InterfacesFor, groupMeta.GroupVersion, options.EtcdStorageConfig.KubernetesStoragePrefix)

+		databaseStorage, err := NewEtcdStorage(etcdClient, groupMeta.GroupVersion, options.EtcdStorageConfig.KubernetesStoragePrefix)

 		if err != nil {

 			return nil, fmt.Errorf("Error setting up Kubernetes extensions server storage: %v", err)

 		}

@@ -249,8 +253,7 @@ func BuildKubernetesMasterConfig(options configapi.MasterConfig, requestContextM

 		Authorizer:       apiserver.NewAlwaysAllowAuthorizer(),

 		AdmissionControl: admissionController,

-		EnableExp: len(enabledExtensionsVersions) > 0,

-		DisableV1: !enabledKubeVersionSet.Has("v1"),

+		APIGroupVersionOverrides: getAPIGroupVersionOverrides(options),

 		// Set the TLS options for proxying to pods and services

 		// Proxying to nodes uses the kubeletClient TLS config (so can provide a different cert, and verify the node hostname)

@@ -261,9 +264,6 @@ func BuildKubernetesMasterConfig(options configapi.MasterConfig, requestContextM

 		},

 	}

-	// set for consistency -- Origin only used m.EnableExp

-	cmserver.EnableExperimental = m.EnableExp

-

 	if options.DNSConfig != nil {

 		_, dnsPortStr, err := net.SplitHostPort(options.DNSConfig.BindAddress)

 		if err != nil {

@@ -294,3 +294,33 @@ func BuildKubernetesMasterConfig(options configapi.MasterConfig, requestContextM

 	return kmaster, nil

 }

+

+// getAPIGroupVersionOverrides builds the overrides in the format expected by master.Config.APIGroupVersionOverrides

+func getAPIGroupVersionOverrides(options configapi.MasterConfig) map[string]master.APIGroupVersionOverride {

+	apiGroupVersionOverrides := map[string]master.APIGroupVersionOverride{}

+	for group := range options.KubernetesMasterConfig.DisabledAPIGroupVersions {

+		for _, version := range configapi.GetDisabledAPIVersionsForGroup(*options.KubernetesMasterConfig, group) {

+			gv := unversioned.GroupVersion{Group: group, Version: version}

+			if group == "" {

+				// TODO: when rebasing, check the parseRuntimeConfig impl to make sure we're still building the right magic container

+				// Create "disabled" key for v1 identically to k8s.io/kubernetes/cmd/kube-apiserver/app/server.go#parseRuntimeConfig

+				gv.Group = "api"

+			}

+			apiGroupVersionOverrides[gv.String()] = master.APIGroupVersionOverride{Disable: true}

+		}

+	}

+	return apiGroupVersionOverrides

+}

+

+// NewEtcdStorage returns a storage interface for the provided storage version.

+func NewEtcdStorage(client *etcdclient.Client, version unversioned.GroupVersion, prefix string) (helper storage.Interface, err error) {

+	group, err := kapilatest.Group(version.Group)

+	if err != nil {

+		return nil, err

+	}

+	interfaces, err := group.InterfacesFor(version)

+	if err != nil {

+		return nil, err

+	}

+	return etcdstorage.NewEtcdStorage(client, interfaces.Codec, prefix), nil

+}

new file mode 100644

@@ -0,0 +1,46 @@

+package kubernetes

+

+import (

+	"reflect"

+	"testing"

+

+	"k8s.io/kubernetes/pkg/master"

+

+	configapi "github.com/openshift/origin/pkg/cmd/server/api"

+)

+

+func TestGetAPIGroupVersionOverrides(t *testing.T) {

+	testcases := map[string]struct {

+		DisabledVersions  map[string][]string

+		ExpectedOverrides map[string]master.APIGroupVersionOverride

+	}{

+		"empty": {

+			DisabledVersions:  nil,

+			ExpectedOverrides: map[string]master.APIGroupVersionOverride{},

+		},

+		"* -> v1": {

+			DisabledVersions:  map[string][]string{"": {"*"}},

+			ExpectedOverrides: map[string]master.APIGroupVersionOverride{"api/v1": {Disable: true}},

+		},

+		"v1": {

+			DisabledVersions:  map[string][]string{"": {"v1"}},

+			ExpectedOverrides: map[string]master.APIGroupVersionOverride{"api/v1": {Disable: true}},

+		},

+		"* -> v1beta1": {

+			DisabledVersions:  map[string][]string{"extensions": {"*"}},

+			ExpectedOverrides: map[string]master.APIGroupVersionOverride{"extensions/v1beta1": {Disable: true}},

+		},

+		"extensions/v1beta1": {

+			DisabledVersions:  map[string][]string{"extensions": {"v1beta1"}},

+			ExpectedOverrides: map[string]master.APIGroupVersionOverride{"extensions/v1beta1": {Disable: true}},

+		},

+	}

+

+	for k, tc := range testcases {

+		config := configapi.MasterConfig{KubernetesMasterConfig: &configapi.KubernetesMasterConfig{DisabledAPIGroupVersions: tc.DisabledVersions}}

+		overrides := getAPIGroupVersionOverrides(config)

+		if !reflect.DeepEqual(overrides, tc.ExpectedOverrides) {

+			t.Errorf("%s: Expected\n%#v\ngot\n%#v", k, tc.ExpectedOverrides, overrides)

+		}

+	}

+}

@@ -24,6 +24,7 @@ import (

 	"k8s.io/kubernetes/pkg/api"

 	klatest "k8s.io/kubernetes/pkg/api/latest"

 	"k8s.io/kubernetes/pkg/api/meta"

+	"k8s.io/kubernetes/pkg/api/unversioned"

 	"k8s.io/kubernetes/pkg/util"

 	"k8s.io/kubernetes/pkg/util/sets"

 )

@@ -160,26 +161,23 @@ func (c *AssetConfig) addHandlers(mux *http.ServeMux) error {

 	originResources := sets.NewString()

 	k8sResources := sets.NewString()

-	versions := sets.NewString()

-	versions.Insert(latest.Versions...)

-	versions.Insert(klatest.VersionsForLegacyGroup()...)

+	versions := []unversioned.GroupVersion{}

+	versions = append(versions, latest.Versions...)

+	versions = append(versions, klatest.ExternalVersions...)

 	deadOriginVersions := sets.NewString(configapi.DeadOpenShiftAPILevels...)

 	deadKubernetesVersions := sets.NewString(configapi.DeadKubernetesAPILevels...)

-	for _, version := range versions.List() {

-		for kind, t := range api.Scheme.KnownTypes(version) {

-			if strings.Contains(t.PkgPath(), "kubernetes/pkg/expapi") {

-				continue

-			}

+	for _, version := range versions {

+		for kind := range api.Scheme.KnownTypes(version) {

 			if strings.HasSuffix(kind, "List") {

 				continue

 			}

 			resource, _ := meta.KindToResource(kind, false)

-			if latest.OriginKind(kind, version) {

-				if !deadOriginVersions.Has(version) {

+			if latest.OriginKind(version.WithKind(kind)) {

+				if !deadOriginVersions.Has(version.String()) {

 					originResources.Insert(resource)

 				}

 			} else {

-				if !deadKubernetesVersions.Has(version) {

+				if !deadKubernetesVersions.Has(version.String()) {

 					k8sResources.Insert(resource)

 				}

 			}

@@ -551,7 +551,7 @@ func (c *MasterConfig) OriginNamespaceControllerClients() (*osclient.Client, *kc

 	return c.PrivilegedLoopbackOpenShiftClient, c.PrivilegedLoopbackKubernetesClient

 }

-// NewEtcdHelper returns an EtcdHelper for the provided storage version.

+// NewEtcdStorage returns a storage interface for the provided storage version.

 func NewEtcdStorage(client *etcdclient.Client, version unversioned.GroupVersion, prefix string) (oshelper storage.Interface, err error) {

 	interfaces, err := latest.InterfacesFor(version)

 	if err != nil {

@@ -550,7 +550,7 @@ func startControllers(oc *origin.MasterConfig, kc *kubernetes.MasterConfig) erro

 		kc.RunNodeController()

 		kc.RunScheduler()

 		kc.RunReplicationController(rcClient)

-		if kc.Master.EnableExp {

+		if len(configapi.GetEnabledAPIVersionsForGroup(kc.Options, configapi.APIGroupExtensions)) > 0 {

 			kc.RunJobController(jobClient)

 			kc.RunHPAController(hpaOClient, hpaKClient, oc.Options.PolicyConfig.OpenShiftInfrastructureNamespace)

 		}