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

 	"k8s.io/kubernetes/pkg/admission"

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

 	"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/client/clientset_generated/internalclientset"

@@ -205,20 +204,20 @@ func BuildKubernetesMasterConfig(options configapi.MasterConfig, requestContextM

 		storageVersions[configapi.APIGroupKube] = options.EtcdStorageConfig.KubernetesStorageVersion

 	}

-	// TODO: also need to enable this if batch or autoscaling is enabled and doesn't have a storage version set

-	enabledExtensionsVersions := configapi.GetEnabledAPIVersionsForGroup(*options.KubernetesMasterConfig, configapi.APIGroupExtensions)

-	if len(enabledExtensionsVersions) > 0 {

-		groupMeta, err := registered.Group(configapi.APIGroupExtensions)

-		if err != nil {

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

-		}

-		// TODO expose storage version options for api groups

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

+	// enable this if extensions API is enabled (or batch or autoscaling, since they persist to extensions/v1beta1 for now)

+	// TODO: replace this with a loop over configured storage versions

+	extensionsEnabled := len(configapi.GetEnabledAPIVersionsForGroup(*options.KubernetesMasterConfig, configapi.APIGroupExtensions)) > 0

+	batchEnabled := len(configapi.GetEnabledAPIVersionsForGroup(*options.KubernetesMasterConfig, configapi.APIGroupBatch)) > 0

+	autoscalingEnabled := len(configapi.GetEnabledAPIVersionsForGroup(*options.KubernetesMasterConfig, configapi.APIGroupAutoscaling)) > 0

+	if extensionsEnabled || autoscalingEnabled || batchEnabled {

+		// TODO: replace this with a configured storage version for extensions once configuration exposes this

+		extensionsStorageVersion := unversioned.GroupVersion{Group: extensions.GroupName, Version: "v1beta1"}

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

 		if err != nil {

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

 		}

 		storageDestinations.AddAPIGroup(configapi.APIGroupExtensions, databaseStorage)

-		storageVersions[configapi.APIGroupExtensions] = unversioned.GroupVersion{Group: extensions.GroupName, Version: enabledExtensionsVersions[0]}.String()

+		storageVersions[configapi.APIGroupExtensions] = extensionsStorageVersion.String()

 	}

 	// Preserve previous behavior of using the first non-loopback address

@@ -4,7 +4,6 @@ package integration

 import (

 	"testing"

-	"time"

 	testutil "github.com/openshift/origin/test/util"

 	testserver "github.com/openshift/origin/test/util/server"

@@ -12,9 +11,130 @@ import (

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

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

 	expapi "k8s.io/kubernetes/pkg/apis/extensions"

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

 )

+func TestExtensionsAPIDisabledAutoscaleBatchEnabled(t *testing.T) {

+	const projName = "ext-disabled-batch-enabled-proj"

+

+	testutil.RequireEtcd(t)

+	masterConfig, err := testserver.DefaultMasterOptions()

+	if err != nil {

+		t.Fatalf("unexpected error: %v", err)

+	}

+

+	// Disable all extensions API versions

+	// Leave autoscaling/batch APIs enabled

+	masterConfig.KubernetesMasterConfig.DisabledAPIGroupVersions = map[string][]string{"extensions": {"*"}}

+

+	clusterAdminKubeConfig, err := testserver.StartConfiguredMaster(masterConfig)

+	if err != nil {

+		t.Fatalf("unexpected error: %v", err)

+	}

+

+	clusterAdminClient, err := testutil.GetClusterAdminClient(clusterAdminKubeConfig)

+	if err != nil {

+		t.Fatalf("unexpected error: %v", err)

+	}

+

+	clusterAdminKubeClient, err := testutil.GetClusterAdminKubeClient(clusterAdminKubeConfig)

+	if err != nil {

+		t.Fatalf("unexpected error: %v", err)

+	}

+

+	clusterAdminClientConfig, err := testutil.GetClusterAdminClientConfig(clusterAdminKubeConfig)

+	if err != nil {

+		t.Fatalf("unexpected error: %v", err)

+	}

+

+	// create the containing project

+	if _, err := testserver.CreateNewProject(clusterAdminClient, *clusterAdminClientConfig, projName, "admin"); err != nil {

+		t.Fatalf("unexpected error creating the project: %v", err)

+	}

+	projectAdminClient, projectAdminKubeClient, _, err := testutil.GetClientForUser(*clusterAdminClientConfig, "admin")

+	if err != nil {

+		t.Fatalf("unexpected error getting project admin client: %v", err)

+	}

+	if err := testutil.WaitForPolicyUpdate(projectAdminClient, projName, "get", expapi.Resource("horizontalpodautoscalers"), true); err != nil {

+		t.Fatalf("unexpected error waiting for policy update: %v", err)

+	}

+

+	validHPA := &expapi.HorizontalPodAutoscaler{

+		ObjectMeta: kapi.ObjectMeta{Name: "myjob"},

+		Spec: expapi.HorizontalPodAutoscalerSpec{

+			ScaleRef:    expapi.SubresourceReference{Name: "foo", Kind: "ReplicationController", Subresource: "scale"},

+			MaxReplicas: 1,

+		},

+	}

+	validJob := &expapi.Job{

+		ObjectMeta: kapi.ObjectMeta{Name: "myjob"},

+		Spec: expapi.JobSpec{

+			Template: kapi.PodTemplateSpec{

+				Spec: kapi.PodSpec{

+					Containers:    []kapi.Container{{Name: "mycontainer", Image: "myimage"}},

+					RestartPolicy: kapi.RestartPolicyNever,

+				},

+			},

+		},

+	}

+

+	// make sure extensions API objects cannot be listed or created

+	if _, err := projectAdminKubeClient.Extensions().HorizontalPodAutoscalers(projName).List(kapi.ListOptions{}); !errors.IsNotFound(err) {

+		t.Fatalf("expected NotFound error listing HPA, got %v", err)

+	}

+	if _, err := projectAdminKubeClient.Extensions().HorizontalPodAutoscalers(projName).Create(validHPA); !errors.IsNotFound(err) {

+		t.Fatalf("expected NotFound error creating HPA, got %v", err)

+	}

+	if _, err := projectAdminKubeClient.Extensions().Jobs(projName).List(kapi.ListOptions{}); !errors.IsNotFound(err) {

+		t.Fatalf("expected NotFound error listing jobs, got %v", err)

+	}

+	if _, err := projectAdminKubeClient.Extensions().Jobs(projName).Create(validJob); !errors.IsNotFound(err) {

+		t.Fatalf("expected NotFound error creating job, got %v", err)

+	}

+

+	// make sure autoscaling and batch API objects can be listed and created

+	if _, err := projectAdminKubeClient.Autoscaling().HorizontalPodAutoscalers(projName).List(kapi.ListOptions{}); err != nil {

+		t.Fatalf("unexpected error: %#v", err)

+	}

+	if _, err := projectAdminKubeClient.Autoscaling().HorizontalPodAutoscalers(projName).Create(validHPA); err != nil {

+		t.Fatalf("unexpected error: %#v", err)

+	}

+	if _, err := projectAdminKubeClient.Batch().Jobs(projName).List(kapi.ListOptions{}); err != nil {

+		t.Fatalf("unexpected error: %#v", err)

+	}

+	if _, err := projectAdminKubeClient.Batch().Jobs(projName).Create(validJob); err != nil {

+		t.Fatalf("unexpected error: %#v", err)

+	}

+

+	// Delete the containing project

+	if err := testutil.DeleteAndWaitForNamespaceTermination(clusterAdminKubeClient, projName); err != nil {

+		t.Fatalf("unexpected error: %#v", err)

+	}

+

+	// recreate the containing project

+	if _, err := testserver.CreateNewProject(clusterAdminClient, *clusterAdminClientConfig, projName, "admin"); err != nil {

+		t.Fatalf("unexpected error creating the project: %v", err)

+	}

+	projectAdminClient, projectAdminKubeClient, _, err = testutil.GetClientForUser(*clusterAdminClientConfig, "admin")

+	if err != nil {

+		t.Fatalf("unexpected error getting project admin client: %v", err)

+	}

+	if err := testutil.WaitForPolicyUpdate(projectAdminClient, projName, "get", expapi.Resource("horizontalpodautoscalers"), true); err != nil {

+		t.Fatalf("unexpected error waiting for policy update: %v", err)

+	}

+

+	// make sure the created objects got cleaned up by namespace deletion

+	if hpas, err := projectAdminKubeClient.Autoscaling().HorizontalPodAutoscalers(projName).List(kapi.ListOptions{}); err != nil {

+		t.Fatalf("unexpected error: %#v", err)

+	} else if len(hpas.Items) > 0 {

+		t.Fatalf("expected 0 HPA objects, got %#v", hpas.Items)

+	}

+	if jobs, err := projectAdminKubeClient.Batch().Jobs(projName).List(kapi.ListOptions{}); err != nil {

+		t.Fatalf("unexpected error: %#v", err)

+	} else if len(jobs.Items) > 0 {

+		t.Fatalf("expected 0 Job objects, got %#v", jobs.Items)

+	}

+}

+

 func TestExtensionsAPIDisabled(t *testing.T) {

 	const projName = "ext-disabled-proj"

@@ -73,17 +193,8 @@ func TestExtensionsAPIDisabled(t *testing.T) {

 		t.Fatalf("expected NotFound error creating job, got %v", err)

 	}

-	if err := clusterAdminClient.Projects().Delete(projName); err != nil {

-		t.Fatalf("unexpected error deleting the project: %v", err)

-	}

-	err = wait.PollImmediate(1*time.Second, 30*time.Second, func() (bool, error) {

-		_, err := clusterAdminKubeClient.Namespaces().Get(projName)

-		if errors.IsNotFound(err) {

-			return true, nil

-		}

-		return false, err

-	})

-	if err != nil {

-		t.Fatalf("unexpected error while waiting for project to delete: %v", err)

+	// Delete the containing project

+	if err := testutil.DeleteAndWaitForNamespaceTermination(clusterAdminKubeClient, projName); err != nil {

+		t.Fatalf("unexpected error: %#v", err)

 	}

 }

@@ -4,8 +4,12 @@ import (

 	"fmt"

 	"time"

-	"github.com/openshift/origin/pkg/cmd/util"

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

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

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

+

+	"github.com/openshift/origin/pkg/cmd/cli/cmd"

+	"github.com/openshift/origin/pkg/cmd/util"

 )

 // Namespace returns the test namespace. The default namespace is set to

@@ -33,3 +37,24 @@ func CreateNamespace(clusterAdminKubeConfig, name string) (err error) {

 	})

 	return err

 }

+

+func DeleteAndWaitForNamespaceTermination(c *kclient.Client, name string) error {

+	w, err := c.Namespaces().Watch(kapi.ListOptions{})

+	if err != nil {

+		return err

+	}

+	if err := c.Namespaces().Delete(name); err != nil {

+		return err

+	}

+	_, err = cmd.Until(30*time.Second, w, func(event watch.Event) (bool, error) {

+		if event.Type != watch.Deleted {

+			return false, nil

+		}

+		namespace, ok := event.Object.(*kapi.Namespace)

+		if !ok {

+			return false, nil

+		}

+		return namespace.Name == name, nil

+	})

+	return err

+}